From f852a93b91ac8359006f8069d0b0bd97d77328a3 Mon Sep 17 00:00:00 2001 From: shenw Date: Mon, 22 Jun 2026 22:02:13 +0800 Subject: [PATCH] Add implicit linear static solver --- CMakeLists.txt | 13 ++ src/base/fem_api.f90 | 20 +++ src/solver/fem_solver_implicit.f90 | 195 ++++++++++++++++++++++++++ tests/module/test_solver_implicit.f90 | 179 +++++++++++++++++++++++ 4 files changed, 407 insertions(+) create mode 100644 src/solver/fem_solver_implicit.f90 create mode 100644 tests/module/test_solver_implicit.f90 diff --git a/CMakeLists.txt b/CMakeLists.txt index e6548ed..6ffc9ca 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -50,6 +50,7 @@ add_library(femlite_core STATIC src/solver/fem_sparse_csr.f90 src/solver/fem_linear_solver_cg.f90 src/solver/fem_assembly_csr.f90 + src/solver/fem_solver_implicit.f90 src/coupling/fem_coupling.f90 src/boundary/fem_boundary.f90 src/output/fem_output_csv.f90 @@ -143,6 +144,13 @@ add_executable(test_element_stiffness target_link_libraries(test_element_stiffness PRIVATE femlite_core) femlite_apply_fortran_options(test_element_stiffness) +add_executable(test_solver_implicit + tests/module/test_solver_implicit.f90 +) + +target_link_libraries(test_solver_implicit PRIVATE femlite_core) +femlite_apply_fortran_options(test_solver_implicit) + add_executable(perf_p1 tests/performance/perf_p1.f90 ) @@ -199,3 +207,8 @@ add_test(NAME element_stiffness COMMAND test_element_stiffness) set_tests_properties(element_stiffness PROPERTIES WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" ) + +add_test(NAME solver_implicit COMMAND test_solver_implicit) +set_tests_properties(solver_implicit PROPERTIES + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" +) diff --git a/src/base/fem_api.f90 b/src/base/fem_api.f90 index 0c83fab..e8e6f8c 100644 --- a/src/base/fem_api.f90 +++ b/src/base/fem_api.f90 @@ -9,6 +9,7 @@ module fem_api use fem_element_state use fem_element_mass use fem_element_internal + use fem_solver_implicit use fem_coupling use fem_boundary use fem_output_csv @@ -854,6 +855,25 @@ contains ierr = FEM_SUCCESS end subroutine fem_run_explicit + subroutine fem_solve_implicit_linear(max_iter, tol, iter, res_norm, ierr) + integer, intent(in) :: max_iter + real(rk), intent(in) :: tol + integer, intent(out) :: iter + real(rk), intent(out) :: res_norm + integer, intent(out) :: ierr + + if (.not. api_initialized) then + call error_set(FEM_ERR_INTERNAL, 'fem_solve_implicit_linear called before fem_initialize', ierr) + return + end if + + call implicit_solve_linear_static(current_time, max_iter, tol, iter, res_norm, ierr) + if (ierr .ne. FEM_SUCCESS) return + + current_step = current_step + 1 + call log_info('implicit linear solve completed') + end subroutine fem_solve_implicit_linear + subroutine fem_get_current_time(time, step, ierr) real(rk), intent(out) :: time integer, intent(out) :: step diff --git a/src/solver/fem_solver_implicit.f90 b/src/solver/fem_solver_implicit.f90 new file mode 100644 index 0000000..1852d98 --- /dev/null +++ b/src/solver/fem_solver_implicit.f90 @@ -0,0 +1,195 @@ +module fem_solver_implicit + use fem_precision + use fem_error + use fem_database + use fem_sparse_csr + use fem_assembly_csr + use fem_linear_solver_cg + use fem_element_stiffness + use fem_boundary + implicit none + + private + + public :: implicit_solve_linear_static + +contains + + subroutine implicit_solve_linear_static(time, max_iter, tol, iter, res_norm, ierr) + real(rk), intent(in) :: time + integer, intent(in) :: max_iter + real(rk), intent(in) :: tol + integer, intent(out) :: iter + real(rk), intent(out) :: res_norm + integer, intent(out) :: ierr + type(csr_matrix) :: kmat + real(rk), allocatable :: rhs(:) + integer :: stat + + iter = 0 + res_norm = ZERO + call csr_init(kmat) + + if (ndof .le. 0) then + call error_set(FEM_ERR_SOLVER, 'implicit linear solve requires positive ndof', ierr) + return + end if + if (.not. allocated(u)) then + call error_set(FEM_ERR_INTERNAL, 'implicit linear solve requires allocated solution vector', ierr) + return + end if + + allocate(rhs(ndof), stat=stat) + if (stat .ne. 0) then + call error_set(FEM_ERR_SOLVER, 'failed to allocate implicit RHS', ierr) + return + end if + rhs = ZERO + + call assembly_build_csr_pattern(kmat, ierr) + if (ierr .ne. FEM_SUCCESS) go to 900 + + call assemble_linear_stiffness(kmat, ierr) + if (ierr .ne. FEM_SUCCESS) go to 900 + + call boundary_apply_prescribed_loads(time, ierr) + if (ierr .ne. FEM_SUCCESS) go to 900 + + rhs = fext + if (allocated(fsph)) rhs = rhs + fsph + if (allocated(fcontact)) rhs = rhs + fcontact + + call apply_implicit_dirichlet(kmat, rhs, time, ierr) + if (ierr .ne. FEM_SUCCESS) go to 900 + + u = ZERO + call linear_cg_solve(kmat, rhs, u, max_iter, tol, iter, res_norm, ierr) + if (ierr .ne. FEM_SUCCESS) go to 900 + + if (allocated(v)) v = ZERO + if (allocated(a)) a = ZERO + if (allocated(vhalf)) vhalf = ZERO + +900 continue + call csr_free(kmat, stat) + if (allocated(rhs)) deallocate(rhs) + end subroutine implicit_solve_linear_static + + subroutine assemble_linear_stiffness(kmat, ierr) + type(csr_matrix), intent(inout) :: kmat + integer, intent(out) :: ierr + real(rk), allocatable :: ke(:,:) + integer :: elem_dofs(MAX_ELEM_DOF) + integer :: n_elem_dof + integer :: elem + integer :: stat + + allocate(ke(MAX_ELEM_DOF,MAX_ELEM_DOF), stat=stat) + if (stat .ne. 0) then + call error_set(FEM_ERR_SOLVER, 'failed to allocate implicit element stiffness workspace', ierr) + return + end if + + do elem = 1, nelem + if (elem_status(elem) .ne. 0) cycle + + call element_linear_stiffness(elem, elem_dofs, n_elem_dof, ke, ierr) + if (ierr .ne. FEM_SUCCESS) go to 900 + call assembly_add_element_matrix(kmat, elem_dofs, n_elem_dof, ke, ierr) + if (ierr .ne. FEM_SUCCESS) go to 900 + end do + + ierr = FEM_SUCCESS + +900 continue + if (allocated(ke)) deallocate(ke) + end subroutine assemble_linear_stiffness + + subroutine apply_implicit_dirichlet(kmat, rhs, time, ierr) + type(csr_matrix), intent(inout) :: kmat + real(rk), intent(inout) :: rhs(:) + real(rk), intent(in) :: time + integer, intent(out) :: ierr + integer :: item + integer :: dof_num + real(rk) :: scale + + do item = 1, nbc + scale = database_amplitude_value(bc_amp(item), time) + do dof_num = bc_dof_start(item), bc_dof_end(item) + call apply_bc_target(kmat, rhs, bc_target(item), dof_num, & + scale * bc_value(item), ierr) + if (ierr .ne. FEM_SUCCESS) return + end do + end do + + ierr = FEM_SUCCESS + end subroutine apply_implicit_dirichlet + + subroutine apply_bc_target(kmat, rhs, target, dof_num, value, ierr) + type(csr_matrix), intent(inout) :: kmat + real(rk), intent(inout) :: rhs(:) + character(len=*), intent(in) :: target + integer, intent(in) :: dof_num + real(rk), intent(in) :: value + integer, intent(out) :: ierr + integer :: node + integer :: set_id + integer :: pos + integer :: external_id + integer :: ios + + if (dof_num .lt. 1 .or. dof_num .gt. NDOF_NODE) then + call error_set(FEM_ERR_INPUT, 'implicit boundary dof is outside 1..6', ierr) + return + end if + + read(target,*,iostat=ios) external_id + if (ios .eq. 0) then + node = database_find_node(external_id) + if (node .eq. 0) then + call error_set(FEM_ERR_INPUT, 'implicit boundary references unknown node', ierr) + return + end if + call apply_bc_node(kmat, rhs, node, dof_num, value, ierr) + return + end if + + set_id = database_find_nset(target) + if (set_id .eq. 0) then + call error_set(FEM_ERR_INPUT, 'implicit boundary references unknown node set', ierr) + return + end if + + do pos = nset_start(set_id), nset_start(set_id) + nset_count(set_id) - 1 + node = database_find_node(nset_items(pos)) + if (node .eq. 0) then + call error_set(FEM_ERR_INPUT, 'implicit boundary node set contains unknown node', ierr) + return + end if + call apply_bc_node(kmat, rhs, node, dof_num, value, ierr) + if (ierr .ne. FEM_SUCCESS) return + end do + + ierr = FEM_SUCCESS + end subroutine apply_bc_target + + subroutine apply_bc_node(kmat, rhs, node, dof_num, value, ierr) + type(csr_matrix), intent(inout) :: kmat + real(rk), intent(inout) :: rhs(:) + integer, intent(in) :: node + integer, intent(in) :: dof_num + real(rk), intent(in) :: value + integer, intent(out) :: ierr + integer :: dof + + dof = dof_id(dof_num,node) + if (dof .gt. 0) then + call csr_apply_dirichlet(kmat, rhs, dof, value, ierr) + if (ierr .ne. FEM_SUCCESS) return + end if + + ierr = FEM_SUCCESS + end subroutine apply_bc_node + +end module fem_solver_implicit diff --git a/tests/module/test_solver_implicit.f90 b/tests/module/test_solver_implicit.f90 new file mode 100644 index 0000000..74f25d0 --- /dev/null +++ b/tests/module/test_solver_implicit.f90 @@ -0,0 +1,179 @@ +program test_solver_implicit + use fem_precision + use fem_error + use fem_database + use fem_solver_implicit + implicit none + + real(rk), parameter :: TOL = 1.0e-10_rk + + call check_single_dof_pull() + call check_prescribed_value() + +contains + + subroutine check_single_dof_pull() + integer :: ierr + integer :: iter + real(rk) :: res_norm + real(rk) :: expected + integer :: dof + + call setup_pull_model(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(1) + + call implicit_solve_linear_static(ZERO, 50, 1.0e-12_rk, iter, res_norm, ierr) + if (ierr .ne. FEM_SUCCESS) call fail(2) + if (iter .le. 0 .or. iter .gt. 5) call fail(3) + if (res_norm .gt. TOL) call fail(4) + + dof = dof_id(1,2) + expected = 5.0_rk / 6.0_rk + call check_close(u(dof), expected, 5) + call check_close(u(dof_id(2,2)), ZERO, 6) + call check_close(u(dof_id(3,2)), ZERO, 7) + call check_close(maxval(abs(v)), ZERO, 8) + call check_close(maxval(abs(a)), ZERO, 9) + + call database_finalize(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(10) + end subroutine check_single_dof_pull + + subroutine check_prescribed_value() + integer :: ierr + integer :: iter + real(rk) :: res_norm + integer :: dof + + call setup_prescribed_model(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(20) + + call implicit_solve_linear_static(ZERO, 50, 1.0e-12_rk, iter, res_norm, ierr) + if (ierr .ne. FEM_SUCCESS) call fail(21) + if (res_norm .gt. TOL) call fail(22) + + dof = dof_id(1,2) + call check_close(u(dof), 0.25_rk, 23) + call check_close(maxval(abs(v)), ZERO, 24) + call check_close(maxval(abs(a)), ZERO, 25) + + call database_finalize(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(26) + end subroutine check_prescribed_value + + subroutine setup_pull_model(ierr) + integer, intent(out) :: ierr + + call setup_base_tet(4, 1, ierr) + if (ierr .ne. FEM_SUCCESS) return + + bc_target(1) = '1' + bc_dof_start(1) = 1 + bc_dof_end(1) = 3 + bc_value(1) = ZERO + + bc_target(2) = '2' + bc_dof_start(2) = 2 + bc_dof_end(2) = 3 + bc_value(2) = ZERO + + bc_target(3) = '3' + bc_dof_start(3) = 1 + bc_dof_end(3) = 3 + bc_value(3) = ZERO + + bc_target(4) = '4' + bc_dof_start(4) = 1 + bc_dof_end(4) = 3 + bc_value(4) = ZERO + + cload_target(1) = '2' + cload_dof(1) = 1 + cload_value(1) = 5.0_rk + ierr = FEM_SUCCESS + end subroutine setup_pull_model + + subroutine setup_prescribed_model(ierr) + integer, intent(out) :: ierr + + call setup_base_tet(5, 0, ierr) + if (ierr .ne. FEM_SUCCESS) return + + bc_target(1) = '1' + bc_dof_start(1) = 1 + bc_dof_end(1) = 3 + bc_value(1) = ZERO + + bc_target(2) = '2' + bc_dof_start(2) = 1 + bc_dof_end(2) = 1 + bc_value(2) = 0.25_rk + + bc_target(3) = '2' + bc_dof_start(3) = 2 + bc_dof_end(3) = 3 + bc_value(3) = ZERO + + bc_target(4) = '3' + bc_dof_start(4) = 1 + bc_dof_end(4) = 3 + bc_value(4) = ZERO + + bc_target(5) = '4' + bc_dof_start(5) = 1 + bc_dof_end(5) = 3 + bc_value(5) = ZERO + ierr = FEM_SUCCESS + end subroutine setup_prescribed_model + + subroutine setup_base_tet(num_bc, num_cload, ierr) + integer, intent(in) :: num_bc + integer, intent(in) :: num_cload + integer, intent(out) :: ierr + integer :: i + + call database_allocate_model(4, 1, 0, 0, 0, 0, 1, 0, 0, & + 0, 0, num_bc, num_cload, 0, ierr) + if (ierr .ne. FEM_SUCCESS) return + + do i = 1, 4 + node_id_ext(i) = i + coord0(:,i) = ZERO + coord(:,i) = ZERO + end do + coord0(:,2) = (/ ONE, ZERO, ZERO /) + coord0(:,3) = (/ ZERO, ONE, ZERO /) + coord0(:,4) = (/ ZERO, ZERO, ONE /) + + elem_id_ext(1) = 1 + elem_type(1) = 'C3D4' + elem_nnode(1) = 4 + elem_conn(:,1) = 0 + elem_conn(1:4,1) = (/ 1, 2, 3, 4 /) + elem_mat(1) = 1 + elem_sec(1) = 1 + + mat_name(1) = 'MAT' + mat_density(1) = ONE + mat_e(1) = 30.0_rk + mat_nu(1) = 0.25_rk + + call database_assign_dofs(ierr) + end subroutine setup_base_tet + + subroutine check_close(actual, expected, code) + real(rk), intent(in) :: actual + real(rk), intent(in) :: expected + integer, intent(in) :: code + + if (abs(actual - expected) .gt. TOL) call fail(code) + end subroutine check_close + + subroutine fail(code) + integer, intent(in) :: code + + write(*,*) 'test_solver_implicit failed:', code + stop 1 + end subroutine fail + +end program test_solver_implicit