finite_elasticity_fluid_pressure_routines.f90

Go to the documentation of this file.

MODULE finite_elasticity_fluid_pressure_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 finite_elasticity_routines
  USE input_output
  USE iso_varying_string
  USE kinds
  USE problem_constants
  USE strings
  USE solver_routines
  USE types

#include "macros.h"  

  IMPLICIT NONE

  PUBLIC finelasticityfluidpressure_equationssetsetup
  PUBLIC finelasticityfluidpressure_equationssetsolnmethodset
  PUBLIC finelasticityfluidpressure_equationssetspecificationset

  PUBLIC elasticity_fluid_pressure_problem_setup
  PUBLIC finelasticityfluidpressure_problemspecificationset
  
  PUBLIC finelasticityfluidpressure_finiteelementcalculate

  PUBLIC elasticity_fluid_pressure_pre_solve
  PUBLIC elasticity_fluid_pressure_post_solve

  PUBLIC finelasticityfluidpressure_controllooppreloop

CONTAINS

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

  SUBROUTINE finelasticityfluidpressure_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("FinElasticityFluidPressure_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 "// &
          & "finite elasticity-fluid pressure class equations set.",err,error,*999)
      END IF
      SELECT CASE(equations_set%SPECIFICATION(3))
      CASE(equations_set_elasticity_fluid_pressure_static_inria_subtype, &
          & equations_set_elasticity_fluid_pressure_holmes_mow_subtype, &
          & equations_set_elasticity_fluid_pres_holmes_mow_active_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 fluid pressure 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("FinElasticityFluidPressure_EquationsSetSolnMethodSet")
    RETURN
999 errors("FinElasticityFluidPressure_EquationsSetSolnMethodSet",err,error)
    exits("FinElasticityFluidPressure_EquationsSetSolnMethodSet")
    RETURN 1
    
  END SUBROUTINE finelasticityfluidpressure_equationssetsolnmethodset

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

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

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

    exits("FinElasticityFluidPressure_EquationsSetSpecificationSet")
    RETURN
999 errors("FinElasticityFluidPressure_EquationsSetSpecificationSet",err,error)
    exits("FinElasticityFluidPressure_EquationsSetSpecificationSet")
    RETURN 1
    
  END SUBROUTINE finelasticityfluidpressure_equationssetspecificationset

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

  SUBROUTINE finelasticityfluidpressure_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


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

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

    exits("FinElasticityFluidPressure_EquationsSetSetup")
    RETURN
999 errors("FinElasticityFluidPressure_EquationsSetSetup",err,error)
    exits("FinElasticityFluidPressure_EquationsSetSetup")
    RETURN 1
    
  END SUBROUTINE finelasticityfluidpressure_equationssetsetup

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

  SUBROUTINE finelasticityfluidpressure_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

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

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

    exits("FinElasticityFluidPressure_FiniteElementCalculate")
    RETURN
999 errors("FinElasticityFluidPressure_FiniteElementCalculate",err,error)
    exits("FinElasticityFluidPressure_FiniteElementCalculate")
    RETURN 1
    
  END SUBROUTINE finelasticityfluidpressure_finiteelementcalculate

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

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

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

    exits("FinElasticityFluidPressure_ProblemSpecificationSet")
    RETURN
999 errors("FinElasticityFluidPressure_ProblemSpecificationSet",err,error)
    exits("FinElasticityFluidPressure_ProblemSpecificationSet")
    RETURN 1
    
  END SUBROUTINE finelasticityfluidpressure_problemspecificationset

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

  SUBROUTINE elasticity_fluid_pressure_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
    TYPE(solver_equations_type), POINTER :: SOLVER_EQUATIONS
    TYPE(solvers_type), POINTER :: SOLVERS
    TYPE(varying_string) :: LOCAL_ERROR

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

    NULLIFY(control_loop)
    NULLIFY(solver)
    NULLIFY(solvers)
    NULLIFY(solver_equations)
    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 finite elasticity fluid pressure
      !--------------------------------------------------------------------
      CASE(problem_standard_elasticity_fluid_pressure_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 fluid pressure  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 load increment loop
            CALL control_loop_create_start(problem,control_loop,err,error,*999)
            CALL control_loop_type_set(control_loop,problem_control_load_increment_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 finite elasticity fluid pressure 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 for the solver
            CALL solvers_create_start(control_loop,solvers,err,error,*999)
            CALL solvers_number_set(solvers,1,err,error,*999)
            !
            !Set the first solver to be a nonlinear solver
            CALL solvers_solver_get(solvers,1,solver,err,error,*999)
            CALL solver_type_set(solver,solver_nonlinear_type,err,error,*999)
            CALL solver_library_type_set(solver,solver_petsc_library,err,error,*999)
          CASE(problem_setup_finish_action)
            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 fluid pressure 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 nonlinear solver and create the solver equations
            CALL solvers_solver_get(solvers,1,solver,err,error,*999)
            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_static,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)
            CALL control_loop_solvers_get(control_loop,solvers,err,error,*999)
            !
            !Finish the creation of the solver equations
            CALL solvers_solver_get(solvers,1,solver,err,error,*999)
            CALL solver_solver_equations_get(solver,solver_equations,err,error,*999)
            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 fluid pressure 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 fluid pressure 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 fluid pressure equation subtype."
        CALL flagerror(local_error,err,error,*999)

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

  !
  !================================================================================================================================
  !
 
  SUBROUTINE elasticity_fluid_pressure_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("ELASTICITY_FLUID_PRESSURE_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 an elasticity fluid pressure problem.",err,error,*999)
          END IF
          SELECT CASE(control_loop%PROBLEM%SPECIFICATION(3))
          CASE(problem_standard_elasticity_fluid_pressure_subtype)
            IF(control_loop%LOOP_TYPE==problem_control_load_increment_loop_type) THEN
              CALL finite_elasticity_pre_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 fluid pressure fluid 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("ELASTICITY_FLUID_PRESSURE_PRE_SOLVE")
    RETURN
999 errorsexits("ELASTICITY_FLUID_PRESSURE_PRE_SOLVE",err,error)
    RETURN 1
  END SUBROUTINE elasticity_fluid_pressure_pre_solve
      
  !   
  !================================================================================================================================
  !

  SUBROUTINE elasticity_fluid_pressure_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("ELASTICITY_FLUID_PRESSURE_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 an elasticity fluid pressure problem.",err,error,*999)
          END IF
          SELECT CASE(control_loop%PROBLEM%SPECIFICATION(3))
          CASE(problem_standard_elasticity_fluid_pressure_subtype)
            CALL finite_elasticity_post_solve(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 finite elasticity fluid pressure 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("ELASTICITY_FLUID_PRESSURE_POST_SOLVE")
    RETURN
999 errorsexits("ELASTICITY_FLUID_PRESSURE_POST_SOLVE",err,error)
    RETURN 1
  END SUBROUTINE elasticity_fluid_pressure_post_solve

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

  SUBROUTINE finelasticityfluidpressure_controllooppreloop(CONTROL_LOOP,ERR,ERROR,*)

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

    !Local Variables
    TYPE(solver_type), POINTER :: SOLVER_FLUID_PRESSURE
    TYPE(control_loop_type), POINTER :: CONTROL_LOOP_FLUID_PRESSURE

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

    NULLIFY(control_loop_fluid_pressure)
    NULLIFY(solver_fluid_pressure)

    IF(ASSOCIATED(control_loop)) THEN
      IF(ASSOCIATED(control_loop%PROBLEM)) THEN
        ! Eventually we may want to do different things depending on problem type/subtype
        ! too but for now we can just check the loop type.
        SELECT CASE(control_loop%LOOP_TYPE)
        CASE(problem_control_load_increment_loop_type)
          IF(control_loop%OUTPUT_TYPE>=control_loop_progress_output) THEN
            CALL write_string(general_output_type,"------------------------------------",err,error,*999)
            CALL write_string(general_output_type,"-- Starting load increment --",err,error,*999)
            CALL write_string_value(general_output_type,"LOAD INCREMENT NUMBER =           ", &
              & control_loop%LOAD_INCREMENT_LOOP%ITERATION_NUMBER,err,error,*999)
            CALL write_string(general_output_type,"------------------------------------",err,error,*999)
          ENDIF
          IF(diagnostics1) THEN
            CALL write_string(diagnostic_output_type,"------------------------------------",err,error,*999)
            CALL write_string(diagnostic_output_type,"-- Starting load increment --",err,error,*999)
            CALL write_string_value(diagnostic_output_type,"LOAD INCREMENT NUMBER =           ", &
              & control_loop%LOAD_INCREMENT_LOOP%ITERATION_NUMBER,err,error,*999)
            CALL write_string(diagnostic_output_type,"------------------------------------",err,error,*999)
          ENDIF

        CASE DEFAULT
          !do nothing
        END SELECT
      ELSE
        CALL flagerror("Problem is not associated.",err,error,*999)
      ENDIF
    ELSE
      CALL flagerror("Control loop is not associated.",err,error,*999)
    ENDIF

    exits("FinElasticityFluidPressure_ControlLoopPreLoop")
    RETURN
999 errors("FinElasticityFluidPressure_ControlLoopPreLoop",err,error)
    exits("FinElasticityFluidPressure_ControlLoopPreLoop")
    RETURN 1
    
  END SUBROUTINE finelasticityfluidpressure_controllooppreloop

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

END MODULE finite_elasticity_fluid_pressure_routines