fsi_routines.f90

Go to the documentation of this file.

MODULE fsi_routines

  USE base_routines
  USE basis_routines
  USE constants
  USE control_loop_routines
  USE equations_routines
  USE equations_mapping_routines
  USE equations_matrices_routines
  USE equations_set_constants
  USE field_io_routines
  USE field_routines
  USE finite_elasticity_routines
  USE input_output
  USE iso_varying_string
  USE kinds
  USE navier_stokes_equations_routines
  USE problem_constants
  USE strings
  USE solver_routines
  USE types

#include "macros.h"  

  IMPLICIT NONE

  PUBLIC fsi_equations_set_setup
  PUBLIC fsi_equationssetspecificationset
  PUBLIC fsi_equations_set_solution_method_set

  PUBLIC fsi_problem_setup
  PUBLIC fsi_problemspecificationset

  PUBLIC fsi_finite_element_calculate

  PUBLIC fsi_pre_solve
  PUBLIC fsi_post_solve

  PUBLIC fsi_control_loop_pre_loop
  PUBLIC fsi_control_loop_post_loop

CONTAINS

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

  SUBROUTINE fsi_equations_set_solution_method_set(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("FSI_EQUATIONS_SET_SOLUTION_METHOD_SET",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 "// &
          & "finite elasticity Navier-Stokes class equations set.",err,error,*999)
      END IF
      SELECT CASE(equations_set%SPECIFICATION(3))
      CASE(equations_set_finite_elasticity_navier_stokes_ale_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 finite elasticity navier stokes 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("FSI_EQUATIONS_SET_SOLUTION_METHOD_SET")
    RETURN
999 errorsexits("FSI_EQUATIONS_SET_SOLUTION_METHOD_SET",err,error)
    RETURN 1
  END SUBROUTINE fsi_equations_set_solution_method_set

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

  SUBROUTINE fsi_equations_set_setup(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


    enters("FSI_EQUATIONS_SET_SETUP",err,error,*999)
    
    CALL flagerror("FSI_EQUATIONS_SET_SETUP is not implemented.",err,error,*999)

    exits("FSI_EQUATIONS_SET_SETUP")
    RETURN
999 errorsexits("FSI_EQUATIONS_SET_SETUP",err,error)
    RETURN 1
  END SUBROUTINE fsi_equations_set_setup

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

  SUBROUTINE fsi_finite_element_calculate(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

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

    CALL flagerror("FSI_FINITE_ELEMENT_CALCULATE is not implemented.",err,error,*999)

    exits("FSI_FINITE_ELEMENT_CALCULATE")
    RETURN
999 errorsexits("FSI_FINITE_ELEMENT_CALCULATE",err,error)
    RETURN 1
  END SUBROUTINE fsi_finite_element_calculate

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

  SUBROUTINE fsi_equationssetspecificationset(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
    !Local Variables

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

    CALL flagerror("FSI_EquationsSetSpecificationSet is not implemented.",err,error,*999)

    exits("FSI_EquationsSetSpecificationSet")
    RETURN
999 errors("FSI_EquationsSetSpecificationSet",err,error)
    exits("FSI_EquationsSetSpecificationSet")
    RETURN 1
    
  END SUBROUTINE fsi_equationssetspecificationset

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

  SUBROUTINE fsi_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("FSI_ProblemSpecificationSet",err,error,*999)

    IF(ASSOCIATED(problem)) THEN
      IF(SIZE(problemspecification,1)==3) THEN
        problemsubtype=problemspecification(3)
        SELECT CASE(problemsubtype)
        CASE(problem_finite_elasticity_navier_stokes_ale_subtype)
          !ok
        CASE DEFAULT
          localerror="The third problem specification of "//trim(numbertovstring(problemsubtype,"*",err,error))// &
            & " is not valid for a finite elasticity Navier-Stokes 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_finite_elasticity_navier_stokes_type, &
          & problemsubtype]
      ELSE
        CALL flagerror("Finite elasticity Navier-Stokes problem specificaion must have three entries.",err,error,*999)
      END IF
    ELSE
      CALL flagerror("Problem is not associated.",err,error,*999)
    END IF

    exits("FSI_ProblemSpecificationSet")
    RETURN
999 errors("FSI_ProblemSpecificationSet",err,error)
    exits("FSI_ProblemSpecificationSet")
    RETURN 1
    
  END SUBROUTINE fsi_problemspecificationset

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

  SUBROUTINE fsi_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(control_loop_type), POINTER :: MovingMeshSubLoop,ElasticitySubLoop
    TYPE(solver_type), POINTER :: SOLVER,MOVING_MESH_SOLVER
    TYPE(solver_equations_type), POINTER :: SOLVER_EQUATIONS,MovingMeshSolverEquations,MOVING_MESH_SOLVER_EQUATIONS
    TYPE(solvers_type), POINTER :: MovingMeshSolvers,SOLVERS
    TYPE(varying_string) :: LOCAL_ERROR

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

    NULLIFY(control_loop)
    NULLIFY(movingmeshsubloop)
    NULLIFY(elasticitysubloop)
    NULLIFY(solver)
    NULLIFY(moving_mesh_solver)
    NULLIFY(solver_equations)
    NULLIFY(moving_mesh_solver_equations)
    NULLIFY(movingmeshsolverequations)
    NULLIFY(solvers)
    NULLIFY(movingmeshsolvers)
    
    IF(ASSOCIATED(problem)) THEN
      IF(ALLOCATED(problem%specification)) 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 finite elasticity-Darcy problem.", &
            & err,error,*999)
        END IF
      ELSE
        CALL flagerror("Problem specification is not allocated.",err,error,*999)
      END IF
      SELECT CASE(problem%SPECIFICATION(3))
        !Standard FiniteElasticity NavierStokes ALE
        CASE(problem_finite_elasticity_navier_stokes_ale_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 an finite elasticity ALE navier stokes 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 as parent 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)
                  CALL control_loop_output_type_set(control_loop,control_loop_progress_output,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 finite elasticity navier stokes 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 Laplace mesh movement problem
                  CALL solvers_solver_get(solvers,2,moving_mesh_solver,err,error,*999)
                  CALL solver_type_set(moving_mesh_solver,solver_linear_type,err,error,*999)
                  !Set solver defaults
                  CALL solver_library_type_set(moving_mesh_solver,solver_petsc_library,err,error,*999)
                  !Set the solver to be a first order dynamic solver 
                  CALL solvers_solver_get(solvers,1,solver,err,error,*999)
                  CALL solver_type_set(solver,solver_dynamic_type,err,error,*999)
                  CALL solver_dynamic_linearity_type_set(solver,solver_dynamic_nonlinear,err,error,*999)
                  CALL solver_dynamic_order_set(solver,solver_dynamic_first_order,err,error,*999)
                  !Set solver defaults
                  CALL solver_dynamic_degree_set(solver,solver_dynamic_first_degree,err,error,*999)
                  CALL solver_dynamic_scheme_set(solver,solver_dynamic_crank_nicolson_scheme,err,error,*999)
                  CALL solver_library_type_set(solver,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 finite elasticity navier stokes 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
                  control_loop_root=>problem%CONTROL_LOOP
                  CALL control_loop_get(control_loop_root,control_loop_node,control_loop,err,error,*999)
                  !Get the solver
                  CALL control_loop_solvers_get(control_loop,solvers,err,error,*999)
                  CALL solvers_solver_get(solvers,2,moving_mesh_solver,err,error,*999)
                  !Create the solver equations
                  CALL solver_equations_create_start(moving_mesh_solver,moving_mesh_solver_equations,err,error,*999)
                  CALL solver_equations_linearity_type_set(moving_mesh_solver_equations,solver_equations_linear,err,error,*999)
                  CALL solver_equations_time_dependence_type_set(moving_mesh_solver_equations,solver_equations_static, &
                    & err,error,*999)
                  CALL solver_equations_sparsity_type_set(moving_mesh_solver_equations,solver_sparse_matrices,err,error,*999)
                  CALL solvers_solver_get(solvers,1,solver,err,error,*999)
                  !Create the solver equations
                  CALL solver_equations_create_start(solver,solver_equations,err,error,*999)
                  CALL solver_equations_linearity_type_set(solver_equations,solver_equations_nonlinear,err,error,*999)
                  CALL solver_equations_time_dependence_type_set(solver_equations,solver_equations_first_order_dynamic,&
                  & err,error,*999)
                  CALL solver_equations_sparsity_type_set(solver_equations,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)
                  !Get the solver equations
                  CALL control_loop_solvers_get(control_loop,solvers,err,error,*999)
                  CALL solvers_solver_get(solvers,2,moving_mesh_solver,err,error,*999)
                  CALL solver_solver_equations_get(moving_mesh_solver,moving_mesh_solver_equations,err,error,*999)
                  !Finish the solver equations creation
                  CALL solver_equations_create_finish(moving_mesh_solver_equations,err,error,*999)             

                  CALL solvers_solver_get(solvers,1,solver,err,error,*999)
                  CALL solver_solver_equations_get(solver,solver_equations,err,error,*999)
                  !Finish the solver equations creation
                  CALL solver_equations_create_finish(solver_equations,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 finite elasticity navier stokes 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 finite elasticity ALE navier stokes equation."
              CALL flagerror(local_error,err,error,*999)
          END SELECT
        CASE DEFAULT
          local_error="The problem subtype of "//trim(number_to_vstring(problem%SPECIFICATION(3),"*",err,error))// &
            & " does not equal a standard finite elasticity navier stokes equation subtype."
          CALL flagerror(local_error,err,error,*999)
      END SELECT
    ELSE
      CALL flagerror("Problem is not associated.",err,error,*999)
    ENDIF
       
    exits("FSI_PROBLEM_SETUP")
    RETURN
999 errorsexits("FSI_PROBLEM_SETUP",err,error)
    RETURN 1
  END SUBROUTINE fsi_problem_setup

  !
  !================================================================================================================================
  !
 
  SUBROUTINE fsi_pre_solve(ControlLoop,Solver,Err,Error,*)

    !Argument variables
    TYPE(control_loop_type), POINTER :: ControlLoop
    TYPE(solver_type), POINTER :: Solver
    INTEGER(INTG), INTENT(OUT) :: Err
    TYPE(varying_string), INTENT(OUT) :: Error

    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

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

    IF(ASSOCIATED(controlloop)) THEN
      IF(ASSOCIATED(solver)) THEN
        IF(ASSOCIATED(controlloop%problem)) THEN
          IF(.NOT.ALLOCATED(controlloop%problem%specification)) THEN
            CALL flagerror("Problem specification is not allocated.",err,error,*999)
          ELSE IF(SIZE(controlloop%problem%specification,1)<3) THEN
            CALL flagerror("Problem specification must have three entries for an elasticity Navier-Stokes problem.",err,error,*999)
          END IF
          SELECT CASE(controlloop%problem%specification(3))
            CASE(problem_finite_elasticity_navier_stokes_ale_subtype)
              IF(controlloop%LOOP_TYPE==problem_control_time_loop_type) THEN
                CALL write_string(general_output_type,"Running pre-solve steps.",err,error,*999)
                !Pre solve for ALE NavierStokes equations set
                CALL navier_stokes_pre_solve(solver,err,error,*999)
                !Pre solve for FiniteElasticity equations set
                !Nothing to be done???
              ELSE
                CALL flagerror("Incorrect loop type. Must be time loop.",err,error,*999)
              ENDIF
            CASE DEFAULT
              local_error="Problem subtype "//trim(number_to_vstring(controlloop%PROBLEM%SPECIFICATION(3),"*",err,error))// &
                & " is not valid for a finite elasticity navier stokes 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("FSI_PRE_SOLVE")
    RETURN
999 errorsexits("FSI_PRE_SOLVE",err,error)
    RETURN 1
  END SUBROUTINE fsi_pre_solve
      
  !   
  !================================================================================================================================
  !

  SUBROUTINE fsi_post_solve(ControlLoop,Solver,Err,Error,*)

    !Argument variables
    TYPE(control_loop_type), POINTER :: ControlLoop
    TYPE(solver_type), POINTER :: Solver,Solver2
    INTEGER(INTG), INTENT(OUT) :: Err
    TYPE(varying_string), INTENT(OUT) :: Error

    !Local Variables
    TYPE(varying_string) :: LOCAL_ERROR

    enters("FSI_POST_SOLVE",err,error,*999)
    
    NULLIFY(solver2)

    IF(ASSOCIATED(controlloop)) THEN
      IF(ASSOCIATED(solver)) THEN
        IF(ASSOCIATED(controlloop%problem)) THEN 
          IF(.NOT.ALLOCATED(controlloop%problem%specification)) THEN
            CALL flagerror("Problem specification is not allocated.",err,error,*999)
          ELSE IF(SIZE(controlloop%problem%specification,1)<3) THEN
            CALL flagerror("Problem specification must have three entries for an elasticity Navier-Stokes problem.",err,error,*999)
          END IF
          SELECT CASE(controlloop%PROBLEM%SPECIFICATION(3))
            CASE(problem_finite_elasticity_navier_stokes_ale_subtype)
              !Post solve for the linear solver
              IF(solver%SOLVE_TYPE==solver_linear_type) THEN
                CALL write_string(general_output_type,"Mesh movement post solve... ",err,error,*999)
                CALL solvers_solver_get(solver%SOLVERS,1,solver2,err,error,*999)
           !     CALL SOLVERS_SOLVER_GET(Solver%SOLVERS,2,Solver2,ERR,ERROR,*999)
                IF(ASSOCIATED(solver2%DYNAMIC_SOLVER)) THEN
                  solver2%DYNAMIC_SOLVER%ALE=.true.
                ELSE  
                  CALL flagerror("Dynamic solver is not associated for ALE problem.",err,error,*999)
                END IF
              !Post solve for the dynamic solver
              ELSE IF(solver%SOLVE_TYPE==solver_dynamic_type) THEN
                CALL write_string(general_output_type,"ALE Navier-Stokes post solve... ",err,error,*999)
     !           IF(.NOT.ASSOCIATED(ControlLoop%TIME_LOOP)) CALL FlagError("Time loop is not associated.",Err,Error,*999)
     !           !Export solid fields
     !           FileName="SolidStep00"//TRIM(NUMBER_TO_VSTRING( &
     !             & INT(ControlLoop%TIME_LOOP%CURRENT_TIME/ControlLoop%TIME_LOOP%TIME_INCREMENT),"*",Err,Error))// &
     !             & "output"
     !           Method="FORTRAN"
     !           CALL FIELD_IO_NODES_EXPORT(Solver%SOLVER_EQUATIONS%SOLVER_MAPPING%EQUATIONS_SETS(1)%PTR%REGION%FIELDS, &
     !             & FileName,Method,ERR,ERROR,*999)
     !           CALL FIELD_IO_ELEMENTS_EXPORT(Solver%SOLVER_EQUATIONS%SOLVER_MAPPING%EQUATIONS_SETS(1)%PTR%REGION%FIELDS, &
     !             & FileName,Method,ERR,ERROR,*999)
     !           !Export fluid fields
     !           FileName="FluidStep00"//TRIM(NUMBER_TO_VSTRING( &
     !             & INT(ControlLoop%TIME_LOOP%CURRENT_TIME/ControlLoop%TIME_LOOP%TIME_INCREMENT),"*",Err,Error))// &
     !             & "output"
     !           Method="FORTRAN"
     !           CALL FIELD_IO_NODES_EXPORT(Solver%SOLVER_EQUATIONS%SOLVER_MAPPING%EQUATIONS_SETS(2)%PTR%REGION%FIELDS, &
     !             & FileName,Method,ERR,ERROR,*999)
     !           CALL FIELD_IO_ELEMENTS_EXPORT(Solver%SOLVER_EQUATIONS%SOLVER_MAPPING%EQUATIONS_SETS(2)%PTR%REGION%FIELDS, &
     !             & FileName,Method,ERR,ERROR,*999)
              ELSE
                local_error="Problem subtype "//trim(number_to_vstring(controlloop%PROBLEM%SPECIFICATION(3),"*",err,error))// &
                  & " for a FiniteElasticity-NavierStokes type of a multi physics problem class has unknown solver solve type."
                CALL flagerror(local_error,err,error,*999)
              END IF
            CASE DEFAULT
              local_error="Problem subtype "//trim(number_to_vstring(controlloop%PROBLEM%SPECIFICATION(3),"*",err,error))// &
                & " is not valid for a FiniteElasticity-NavierStokes 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("FSI_POST_SOLVE")
    RETURN
999 errorsexits("FSI_POST_SOLVE",err,error)
    RETURN 1
  END SUBROUTINE fsi_post_solve

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

  SUBROUTINE fsi_control_loop_pre_loop(ControlLoop,Err,Error,*)

    !Argument variables
    TYPE(control_loop_type), POINTER :: ControlLoop
    INTEGER(INTG), INTENT(OUT) :: Err
    TYPE(varying_string), INTENT(OUT) :: Error

    !Local Variables

    enters("FSI_CONTROL_LOOP_PRE_LOOP",err,error,*999)
    
    CALL flagerror("FSI_CONTROL_LOOP_PRE_LOOP not implemented.",err,error,*999)

    exits("FSI_CONTROL_LOOP_PRE_LOOP")
    RETURN
999 errorsexits("FSI_CONTROL_LOOP_PRE_LOOP",err,error)
    RETURN 1
  END SUBROUTINE fsi_control_loop_pre_loop

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

  SUBROUTINE fsi_control_loop_post_loop(ControlLoop,Err,Error,*)

    !Argument variables
    TYPE(control_loop_type), POINTER :: ControlLoop
    INTEGER(INTG), INTENT(OUT) :: Err
    TYPE(varying_string), INTENT(OUT) :: Error

    !Local Variables
    TYPE(solver_type), POINTER :: DynamicSolver,LinearSolver
    TYPE(control_loop_time_type), POINTER :: TimeLoop
    TYPE(solver_equations_type), POINTER :: DynamicSolverEquations
    TYPE(solver_mapping_type), POINTER :: DynamicSolverMapping
    TYPE(equations_set_type), POINTER :: SolidEquationsSet,FluidEquationsSet,EquationsSet
    TYPE(field_type), POINTER :: SolidGeometricField,InterfaceGeometricField,SolidDependentField
    TYPE(interface_condition_type), POINTER :: InterfaceCondition
    TYPE(interface_type), POINTER :: FSInterface
    TYPE(nodes_type), POINTER :: InterfaceNodes
    TYPE(varying_string) :: Method,SolidFileName,FluidFileName,InterfaceFileName
    REAL(DP) :: StartTime,CurrentTime,TimeIncrement,TimeStepNumber,Value
    INTEGER(INTG) :: EquationsSetIndex,InterfaceNodeNumber,InterfaceNodeComponent,NumberOfComponents
    LOGICAL :: FluidEquationsSetFound,SolidEquationsSetFound=.false.

    enters("FSI_CONTROL_LOOP_POST_LOOP",err,error,*999)
    
    NULLIFY(dynamicsolver)
    NULLIFY(linearsolver)
    NULLIFY(timeloop)
    NULLIFY(dynamicsolverequations)
    NULLIFY(solidequationsset)
    NULLIFY(fluidequationsset)
    NULLIFY(solidgeometricfield)
    NULLIFY(interfacegeometricfield)
    NULLIFY(soliddependentfield)
    NULLIFY(interfacecondition)
    NULLIFY(fsinterface)
    NULLIFY(interfacenodes)
    
    !Check pointers
    IF(.NOT.ASSOCIATED(controlloop)) CALL flagerror("Main control loop not associated.",err,error,*999)
    IF(.NOT.ASSOCIATED(controlloop%SOLVERS)) CALL flagerror("Solvers are not associated.",err,error,*999)
    !Get solvers for FSI
    CALL solvers_solver_get(controlloop%SOLVERS,1,dynamicsolver,err,error,*999)
    CALL solvers_solver_get(controlloop%SOLVERS,2,linearsolver,err,error,*999)
    timeloop=>controlloop%TIME_LOOP
    IF(.NOT.ASSOCIATED(timeloop)) CALL flagerror("Time loop not associated.",err,error,*999)
    !Get times
    starttime=timeloop%START_TIME
    currenttime=timeloop%CURRENT_TIME
    timeincrement=timeloop%TIME_INCREMENT
    timestepnumber=(currenttime-starttime)/timeincrement!GLOBAL_ITERATION_NUMBER???
    !===============================================================================================================================
    !First update mesh and calculate boundary velocity values
    CALL navier_stokes_pre_solve_ale_update_mesh(dynamicsolver,err,error,*999)
    !===============================================================================================================================
    !Update interface geometric field and export results
    dynamicsolverequations=>dynamicsolver%SOLVER_EQUATIONS
    IF(ASSOCIATED(dynamicsolverequations)) THEN
      dynamicsolvermapping=>dynamicsolverequations%SOLVER_MAPPING
      IF(ASSOCIATED(dynamicsolvermapping)) THEN
        equationssetindex=1
        fluidequationssetfound=.false.
        solidequationssetfound=.false.
        DO WHILE((equationssetindex<=dynamicsolvermapping%NUMBER_OF_EQUATIONS_SETS &
          & .AND..NOT.solidequationssetfound) &
          & .OR.(equationssetindex<=dynamicsolvermapping%NUMBER_OF_EQUATIONS_SETS &
          & .AND..NOT.fluidequationssetfound))
          equationsset=>dynamicsolvermapping%EQUATIONS_SETS(equationssetindex)%PTR
          IF(equationsset%specification(1)==equations_set_elasticity_class &
            & .AND.equationsset%specification(2)==equations_set_finite_elasticity_type &
            & .AND.((equationsset%specification(3)==equations_set_mooney_rivlin_subtype).OR. &
            & (equationsset%specification(3)==equations_set_compressible_finite_elasticity_subtype))) THEN
            solidequationsset=>equationsset
            solidequationssetfound=.true.
          ELSEIF(equationsset%specification(1)==equations_set_fluid_mechanics_class &
            & .AND.equationsset%specification(2)==equations_set_navier_stokes_equation_type &
            & .AND.equationsset%specification(3)==equations_set_ale_navier_stokes_subtype) THEN
            fluidequationsset=>equationsset
            fluidequationssetfound=.true.
          ELSE
            CALL flagerror("Invalid equations sets associated with dynamic solver for FSI.", err,error,*999)
          ENDIF
          equationssetindex=equationssetindex+1
        ENDDO
        IF(.NOT.solidequationssetfound) CALL flagerror("Could not find solid equations set for FSI.",err,error,*999)
        IF(.NOT.fluidequationssetfound) CALL flagerror("Could not find fluid equations set for FSI.",err,error,*999)
        solidgeometricfield=>solidequationsset%GEOMETRY%GEOMETRIC_FIELD
        IF(ASSOCIATED(solidgeometricfield)) THEN
          CALL field_number_of_components_get(solidgeometricfield,field_u_variable_type,numberofcomponents,err,error,*999)
          IF(dynamicsolvermapping%NUMBER_OF_INTERFACE_CONDITIONS>1) THEN
            CALL flagerror("Invalid number of interface conditions. Must be 1 for FSI.",err,error,*999)
          ENDIF
          soliddependentfield=>solidequationsset%DEPENDENT%DEPENDENT_FIELD
          IF(ASSOCIATED(soliddependentfield)) THEN
            interfacecondition=>dynamicsolvermapping%INTERFACE_CONDITIONS(1)%PTR
            IF(ASSOCIATED(interfacecondition)) THEN
              fsinterface=>interfacecondition%INTERFACE
              IF(ASSOCIATED(fsinterface)) THEN
                interfacenodes=>fsinterface%NODES
                IF(ASSOCIATED(interfacenodes)) THEN
                  interfacegeometricfield=>interfacecondition%GEOMETRY%GEOMETRIC_FIELD
                  IF(ASSOCIATED(interfacegeometricfield)) THEN
                    !===============================================================================================================
                    !Update interface geometric field
                    DO interfacenodenumber=1,interfacenodes%NUMBER_OF_NODES
                      DO interfacenodecomponent=1,numberofcomponents
                        !Default to version 1, derivative 1
                        CALL field_parameter_set_get_node(soliddependentfield,field_u_variable_type,field_values_set_type, &
                          & 1,1,interfacenodes%COUPLED_NODES(1,interfacenodenumber),interfacenodecomponent,Value, &
                          & err,error,*999)
                        CALL field_parameter_set_update_node(interfacegeometricfield,field_u_variable_type, &
                          & field_values_set_type,1,1,interfacenodenumber,interfacenodecomponent,Value,err,error,*999)
                      ENDDO
                    ENDDO
                    CALL field_parameter_set_update_start(interfacegeometricfield, & 
                      & field_u_variable_type,field_values_set_type,err,error,*999)
                    CALL field_parameter_set_update_finish(interfacegeometricfield, & 
                      & field_u_variable_type,field_values_set_type,err,error,*999)
                    !===============================================================================================================
                    !Export fields
                    solidfilename="./output/Solid/Solid"//trim(number_to_vstring(int(timestepnumber),"*",err,error))
                    fluidfilename="./output/Fluid/Fluid"//trim(number_to_vstring(int(timestepnumber),"*",err,error))
                    interfacefilename="./output/Interface/Interface"//trim(number_to_vstring(int(timestepnumber),"*",err,error))
                    method="FORTRAN"
                    !Export solid fields
                    IF(.NOT.ASSOCIATED(solidequationsset%REGION)) CALL flagerror("Solid region not associated.", &
                      & err,error,*999)
                    IF(.NOT.ASSOCIATED(solidequationsset%REGION%FIELDS)) CALL flagerror("Solid fields not associated.", &
                      & err,error,*999)
                    CALL write_string(general_output_type,"...",err,error,*999)
                    CALL write_string(general_output_type,"Now export fields... ",err,error,*999)
                    CALL field_io_nodes_export(solidequationsset%REGION%FIELDS,solidfilename,method,err,error,*999)
                    CALL field_io_elements_export(solidequationsset%REGION%FIELDS,solidfilename,method,err,error,*999)
                    CALL write_string(general_output_type,solidfilename,err,error,*999)
                    IF(.NOT.ASSOCIATED(fluidequationsset%REGION)) CALL flagerror("Fluid region not associated.", &
                      & err,error,*999)
                    IF(.NOT.ASSOCIATED(fluidequationsset%REGION%FIELDS)) CALL flagerror("Fluid fields not associated.", &
                      & err,error,*999)
                    !Export fluid fields
                    CALL field_io_nodes_export(fluidequationsset%REGION%FIELDS,fluidfilename,method,err,error,*999)
                    CALL field_io_elements_export(fluidequationsset%REGION%FIELDS,fluidfilename,method,err,error,*999)
                    CALL write_string(general_output_type,fluidfilename,err,error,*999)
                    IF(.NOT.ASSOCIATED(fsinterface%FIELDS)) CALL flagerror("Interface fields not associated.",err,error,*999)
                    !Export interface fields
                    CALL field_io_nodes_export(fsinterface%FIELDS,interfacefilename,method,err,error,*999)
                    CALL field_io_elements_export(fsinterface%FIELDS,interfacefilename,method,err,error,*999)
                    CALL write_string(general_output_type,interfacefilename,err,error,*999)
                    CALL write_string(general_output_type,"...",err,error,*999)
                  ELSE
                    CALL flagerror("Interface geometric field not associated.",err,error,*999)
                  ENDIF
                ELSE
                  CALL flagerror("Interface nodes not associated.",err,error,*999)
                ENDIF
              ELSE
                CALL flagerror("Interface not associated.",err,error,*999)
              ENDIF
            ELSE
              CALL flagerror("Interface condition not associated.",err,error,*999)
            ENDIF
          ELSE
            CALL flagerror("Solid dependent field not associated.",err,error,*999)
          ENDIF
        ELSE
          CALL flagerror("Solid geometric field not associated.",err,error,*999)
        ENDIF
      ELSE
        CALL flagerror("Dynamic solver mapping not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Dynamic solver equations not associated.",err,error,*999)
    ENDIF

    exits("FSI_CONTROL_LOOP_POST_LOOP")
    RETURN
999 errorsexits("FSI_CONTROL_LOOP_POST_LOOP",err,error)
    RETURN 1
  END SUBROUTINE fsi_control_loop_post_loop

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

END MODULE fsi_routines