diff --git a/CMakeLists.txt b/CMakeLists.txt index 9ff4ec5..e6548ed 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -46,6 +46,7 @@ add_library(femlite_core STATIC src/element/fem_shape_functions.f90 src/element/fem_element_mass.f90 src/element/fem_element_internal.f90 + src/element/fem_element_stiffness.f90 src/solver/fem_sparse_csr.f90 src/solver/fem_linear_solver_cg.f90 src/solver/fem_assembly_csr.f90 @@ -135,6 +136,13 @@ add_executable(test_assembly_csr target_link_libraries(test_assembly_csr PRIVATE femlite_core) femlite_apply_fortran_options(test_assembly_csr) +add_executable(test_element_stiffness + tests/module/test_element_stiffness.f90 +) + +target_link_libraries(test_element_stiffness PRIVATE femlite_core) +femlite_apply_fortran_options(test_element_stiffness) + add_executable(perf_p1 tests/performance/perf_p1.f90 ) @@ -186,3 +194,8 @@ add_test(NAME assembly_csr COMMAND test_assembly_csr) set_tests_properties(assembly_csr PROPERTIES WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" ) + +add_test(NAME element_stiffness COMMAND test_element_stiffness) +set_tests_properties(element_stiffness PROPERTIES + WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" +) diff --git a/src/element/fem_element_stiffness.f90 b/src/element/fem_element_stiffness.f90 new file mode 100644 index 0000000..8556b5e --- /dev/null +++ b/src/element/fem_element_stiffness.f90 @@ -0,0 +1,284 @@ +module fem_element_stiffness + use fem_precision + use fem_error + use fem_database + use fem_element_topology + use fem_quadrature + use fem_shape_functions + implicit none + + private + + public :: element_linear_stiffness + +contains + + subroutine element_linear_stiffness(elem, elem_dofs, n_elem_dof, ke, ierr) + integer, intent(in) :: elem + integer, intent(out) :: elem_dofs(:) + integer, intent(out) :: n_elem_dof + real(rk), intent(out) :: ke(:,:) + integer, intent(out) :: ierr + character(len=ELEM_TYPE_LEN) :: etype + + elem_dofs = 0 + n_elem_dof = 0 + ke = ZERO + + if (elem .lt. 1 .or. elem .gt. nelem) then + call error_set(FEM_ERR_MESH, 'linear stiffness element index is out of range', ierr) + return + end if + if (.not. element_is_solid(elem_type(elem))) then + call error_set(FEM_ERR_MESH, 'linear stiffness is implemented for solid elements only', ierr) + return + end if + + etype = adjustl(elem_type(elem)) + select case (trim(etype)) + case ('C3D4', 'C3D8') + call solid_linear_stiffness(elem, elem_dofs, n_elem_dof, ke, ierr) + case default + call error_set(FEM_ERR_MESH, 'linear stiffness element type is not implemented', ierr) + end select + end subroutine element_linear_stiffness + + subroutine solid_linear_stiffness(elem, elem_dofs, n_elem_dof, ke, ierr) + integer, intent(in) :: elem + integer, intent(out) :: elem_dofs(:) + integer, intent(out) :: n_elem_dof + real(rk), intent(out) :: ke(:,:) + integer, intent(out) :: ierr + real(rk) :: dmat(NSTRESS,NSTRESS) + real(rk) :: gp_nat(NDIM,27) + real(rk) :: gp_weight(27) + real(rk) :: natural(NDIM) + real(rk) :: nshape(MAX_NEN) + real(rk) :: dndr(NDIM,MAX_NEN) + real(rk) :: dndx(NDIM,MAX_NEN) + real(rk) :: bmat(NSTRESS,MAX_NEN*3) + real(rk) :: db(NSTRESS,MAX_NEN*3) + real(rk) :: detj + real(rk) :: factor + integer :: q + integer :: npoint + integer :: nlocal + + nlocal = elem_nnode(elem) + n_elem_dof = 3 * nlocal + if (size(elem_dofs) .lt. n_elem_dof) then + call error_set(FEM_ERR_INTERNAL, 'linear stiffness dof buffer is too small', ierr) + return + end if + if (size(ke,1) .lt. n_elem_dof .or. size(ke,2) .lt. n_elem_dof) then + call error_set(FEM_ERR_INTERNAL, 'linear stiffness matrix buffer is too small', ierr) + return + end if + + call fill_solid_dofs(elem, elem_dofs, n_elem_dof, ierr) + if (ierr .ne. FEM_SUCCESS) return + call elastic_matrix_3d(elem_mat(elem), dmat, ierr) + if (ierr .ne. FEM_SUCCESS) return + + call quadrature_get_rule(elem_type(elem), 27, npoint, gp_nat, gp_weight, ierr) + if (ierr .ne. FEM_SUCCESS) return + + do q = 1, npoint + natural = gp_nat(:,q) + call shape_evaluate(elem_type(elem), natural, nshape, dndr, ierr) + if (ierr .ne. FEM_SUCCESS) return + call shape_gradients_current(elem, nlocal, dndr, dndx, detj, ierr) + if (ierr .ne. FEM_SUCCESS) return + call build_solid_b(nlocal, dndx, bmat) + + db(:,1:n_elem_dof) = matmul(dmat, bmat(:,1:n_elem_dof)) + factor = gp_weight(q) * detj + ke(1:n_elem_dof,1:n_elem_dof) = ke(1:n_elem_dof,1:n_elem_dof) + & + factor * matmul(transpose(bmat(:,1:n_elem_dof)), db(:,1:n_elem_dof)) + end do + + ierr = FEM_SUCCESS + end subroutine solid_linear_stiffness + + subroutine fill_solid_dofs(elem, elem_dofs, n_elem_dof, ierr) + integer, intent(in) :: elem + integer, intent(out) :: elem_dofs(:) + integer, intent(in) :: n_elem_dof + integer, intent(out) :: ierr + integer :: local_node + integer :: node + integer :: idir + integer :: pos + integer :: dof + + if (.not. allocated(dof_id)) then + call error_set(FEM_ERR_INTERNAL, 'linear stiffness requires assigned dof_id table', ierr) + return + end if + + pos = 0 + do local_node = 1, elem_nnode(elem) + node = elem_conn(local_node, elem) + if (node .lt. 1 .or. node .gt. nnode) then + call error_set(FEM_ERR_MESH, 'linear stiffness element references invalid node', ierr) + return + end if + do idir = 1, NDIM + dof = dof_id(idir,node) + if (dof .le. 0) then + call error_set(FEM_ERR_MESH, 'linear stiffness element has inactive translation dof', ierr) + return + end if + pos = pos + 1 + if (pos .gt. n_elem_dof) then + call error_set(FEM_ERR_INTERNAL, 'linear stiffness dof list overflow', ierr) + return + end if + elem_dofs(pos) = dof + end do + end do + + ierr = FEM_SUCCESS + end subroutine fill_solid_dofs + + subroutine elastic_matrix_3d(mat, dmat, ierr) + integer, intent(in) :: mat + real(rk), intent(out) :: dmat(NSTRESS,NSTRESS) + integer, intent(out) :: ierr + real(rk) :: young + real(rk) :: poisson + real(rk) :: lambda + real(rk) :: mu + + dmat = ZERO + if (mat .lt. 1 .or. mat .gt. n_material) then + call error_set(FEM_ERR_MATERIAL, 'invalid material index for linear stiffness', ierr) + return + end if + + young = mat_e(mat) + poisson = mat_nu(mat) + if (young .le. ZERO) then + call error_set(FEM_ERR_MATERIAL, 'linear stiffness requires positive elastic modulus', ierr) + return + end if + if (poisson .le. -ONE .or. poisson .ge. HALF) then + call error_set(FEM_ERR_MATERIAL, 'linear stiffness Poisson ratio must be in (-1,0.5)', ierr) + return + end if + + lambda = young * poisson / ((ONE + poisson) * (ONE - 2.0_rk * poisson)) + mu = young / (2.0_rk * (ONE + poisson)) + + dmat(1,1) = lambda + 2.0_rk * mu + dmat(2,2) = dmat(1,1) + dmat(3,3) = dmat(1,1) + dmat(1,2) = lambda + dmat(1,3) = lambda + dmat(2,1) = lambda + dmat(2,3) = lambda + dmat(3,1) = lambda + dmat(3,2) = lambda + dmat(4,4) = mu + dmat(5,5) = mu + dmat(6,6) = mu + + ierr = FEM_SUCCESS + end subroutine elastic_matrix_3d + + subroutine shape_gradients_current(elem, nlocal, dndr, dndx, detj, ierr) + integer, intent(in) :: elem + integer, intent(in) :: nlocal + real(rk), intent(in) :: dndr(NDIM,MAX_NEN) + real(rk), intent(out) :: dndx(NDIM,MAX_NEN) + real(rk), intent(out) :: detj + integer, intent(out) :: ierr + real(rk) :: jac(NDIM,NDIM) + real(rk) :: invj(NDIM,NDIM) + integer :: local_node + integer :: node + integer :: i + integer :: j + integer :: k + + jac = ZERO + dndx = ZERO + + do local_node = 1, nlocal + node = elem_conn(local_node, elem) + do i = 1, NDIM + do j = 1, NDIM + jac(i,j) = jac(i,j) + coord0(i,node) * dndr(j,local_node) + end do + end do + end do + + call inverse3(jac, invj, detj, ierr) + if (ierr .ne. FEM_SUCCESS) return + if (detj .le. ZERO) then + call error_set(FEM_ERR_MESH, 'linear stiffness element has non-positive Jacobian', ierr) + return + end if + + do local_node = 1, nlocal + do i = 1, NDIM + dndx(i,local_node) = ZERO + do k = 1, NDIM + dndx(i,local_node) = dndx(i,local_node) + invj(k,i) * dndr(k,local_node) + end do + end do + end do + + ierr = FEM_SUCCESS + end subroutine shape_gradients_current + + subroutine build_solid_b(nlocal, dndx, bmat) + integer, intent(in) :: nlocal + real(rk), intent(in) :: dndx(NDIM,MAX_NEN) + real(rk), intent(out) :: bmat(NSTRESS,MAX_NEN*3) + integer :: local_node + integer :: base + + bmat = ZERO + do local_node = 1, nlocal + base = 3 * (local_node - 1) + bmat(1,base+1) = dndx(1,local_node) + bmat(2,base+2) = dndx(2,local_node) + bmat(3,base+3) = dndx(3,local_node) + bmat(4,base+1) = dndx(2,local_node) + bmat(4,base+2) = dndx(1,local_node) + bmat(5,base+1) = dndx(3,local_node) + bmat(5,base+3) = dndx(1,local_node) + bmat(6,base+2) = dndx(3,local_node) + bmat(6,base+3) = dndx(2,local_node) + end do + end subroutine build_solid_b + + subroutine inverse3(a, ainv, det, ierr) + real(rk), intent(in) :: a(NDIM,NDIM) + real(rk), intent(out) :: ainv(NDIM,NDIM) + real(rk), intent(out) :: det + integer, intent(out) :: ierr + + det = a(1,1) * (a(2,2) * a(3,3) - a(2,3) * a(3,2)) - & + a(1,2) * (a(2,1) * a(3,3) - a(2,3) * a(3,1)) + & + a(1,3) * (a(2,1) * a(3,2) - a(2,2) * a(3,1)) + if (abs(det) .le. tiny(ONE)) then + call error_set(FEM_ERR_MESH, 'linear stiffness element Jacobian is singular', ierr) + return + end if + + ainv(1,1) = (a(2,2) * a(3,3) - a(2,3) * a(3,2)) / det + ainv(1,2) = -(a(1,2) * a(3,3) - a(1,3) * a(3,2)) / det + ainv(1,3) = (a(1,2) * a(2,3) - a(1,3) * a(2,2)) / det + ainv(2,1) = -(a(2,1) * a(3,3) - a(2,3) * a(3,1)) / det + ainv(2,2) = (a(1,1) * a(3,3) - a(1,3) * a(3,1)) / det + ainv(2,3) = -(a(1,1) * a(2,3) - a(1,3) * a(2,1)) / det + ainv(3,1) = (a(2,1) * a(3,2) - a(2,2) * a(3,1)) / det + ainv(3,2) = -(a(1,1) * a(3,2) - a(1,2) * a(3,1)) / det + ainv(3,3) = (a(1,1) * a(2,2) - a(1,2) * a(2,1)) / det + + ierr = FEM_SUCCESS + end subroutine inverse3 + +end module fem_element_stiffness diff --git a/src/solver/fem_assembly_csr.f90 b/src/solver/fem_assembly_csr.f90 index e844f40..cce38d3 100644 --- a/src/solver/fem_assembly_csr.f90 +++ b/src/solver/fem_assembly_csr.f90 @@ -2,6 +2,7 @@ module fem_assembly_csr use fem_precision use fem_error use fem_database + use fem_element_topology use fem_sparse_csr implicit none @@ -25,6 +26,7 @@ contains integer :: local_node integer :: node integer :: dof_num + integer :: last_dof integer :: dof n_elem_dof = 0 @@ -42,6 +44,14 @@ contains call error_set(FEM_ERR_INTERNAL, 'assembly requires allocated element connectivity', ierr) return end if + if (element_is_solid(elem_type(elem))) then + last_dof = 3 + else if (element_is_shell(elem_type(elem))) then + last_dof = NDOF_NODE + else + call error_set(FEM_ERR_MESH, 'unsupported element type for assembly dofs', ierr) + return + end if do local_node = 1, elem_nnode(elem) node = elem_conn(local_node, elem) @@ -49,7 +59,7 @@ contains call error_set(FEM_ERR_MESH, 'assembly element references invalid node', ierr) return end if - do dof_num = 1, NDOF_NODE + do dof_num = 1, last_dof dof = dof_id(dof_num, node) if (dof .gt. 0) then if (n_elem_dof .ge. size(elem_dofs)) then diff --git a/tests/module/test_assembly_csr.f90 b/tests/module/test_assembly_csr.f90 index 0c3cb29..6b47c9d 100644 --- a/tests/module/test_assembly_csr.f90 +++ b/tests/module/test_assembly_csr.f90 @@ -10,6 +10,7 @@ program test_assembly_csr call check_solid_assembly() call check_shell_dof_list() + call check_mixed_dof_filter() contains @@ -114,6 +115,48 @@ contains if (ierr .ne. FEM_SUCCESS) call fail(37) end subroutine check_shell_dof_list + subroutine check_mixed_dof_filter() + integer :: ierr + integer :: elem_dofs(MAX_ELEM_DOF) + integer :: n_elem_dof + + call database_allocate_mesh(5, 2, ierr) + if (ierr .ne. FEM_SUCCESS) call fail(40) + + call fill_node_ids(5) + 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_id_ext(2) = 2 + elem_type(2) = 'S4' + elem_nnode(2) = 4 + elem_conn(:,2) = 0 + elem_conn(1:4,2) = (/ 1, 2, 3, 5 /) + + call database_assign_dofs(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(41) + if (ndof .ne. 27) call fail(42) + + call assembly_get_element_dofs(1, elem_dofs, n_elem_dof, ierr) + if (ierr .ne. FEM_SUCCESS) call fail(43) + if (n_elem_dof .ne. 12) call fail(44) + if (elem_dofs(1) .ne. 1 .or. elem_dofs(4) .ne. 7) call fail(45) + if (elem_dofs(7) .ne. 13 .or. elem_dofs(10) .ne. 19) call fail(46) + if (elem_dofs(12) .ne. 21) call fail(47) + + call assembly_get_element_dofs(2, elem_dofs, n_elem_dof, ierr) + if (ierr .ne. FEM_SUCCESS) call fail(48) + if (n_elem_dof .ne. 24) call fail(49) + if (elem_dofs(1) .ne. 1 .or. elem_dofs(6) .ne. 6) call fail(50) + if (elem_dofs(19) .ne. 22 .or. elem_dofs(24) .ne. 27) call fail(51) + + call database_finalize(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(52) + end subroutine check_mixed_dof_filter + subroutine setup_two_tet_mesh(ierr) integer, intent(out) :: ierr diff --git a/tests/module/test_element_stiffness.f90 b/tests/module/test_element_stiffness.f90 new file mode 100644 index 0000000..df6af30 --- /dev/null +++ b/tests/module/test_element_stiffness.f90 @@ -0,0 +1,209 @@ +program test_element_stiffness + use fem_precision + use fem_error + use fem_database + use fem_element_stiffness + implicit none + + integer, parameter :: MAX_TEST_DOF = 60 + real(rk), parameter :: TOL = 1.0e-8_rk + + call check_c3d4_stiff() + call check_c3d8_stiff() + call check_bad_stiff_type() + +contains + + subroutine check_c3d4_stiff() + integer :: ierr + integer :: elem_dofs(MAX_TEST_DOF) + integer :: n_elem_dof + real(rk) :: ke(MAX_TEST_DOF,MAX_TEST_DOF) + + call setup_c3d4(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(1) + + call element_linear_stiffness(1, elem_dofs, n_elem_dof, ke, ierr) + if (ierr .ne. FEM_SUCCESS) call fail(2) + if (n_elem_dof .ne. 12) call fail(3) + if (elem_dofs(1) .ne. 1 .or. elem_dofs(12) .ne. 12) call fail(4) + call check_symmetric(ke, n_elem_dof, 5) + call check_rigid_translation(ke, n_elem_dof, 1, 6) + call check_rigid_translation(ke, n_elem_dof, 2, 7) + call check_rigid_translation(ke, n_elem_dof, 3, 8) + call check_positive_energy(ke, n_elem_dof, 9) + + call database_finalize(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(10) + end subroutine check_c3d4_stiff + + subroutine check_c3d8_stiff() + integer :: ierr + integer :: elem_dofs(MAX_TEST_DOF) + integer :: n_elem_dof + real(rk) :: ke(MAX_TEST_DOF,MAX_TEST_DOF) + + call setup_c3d8(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(20) + + call element_linear_stiffness(1, elem_dofs, n_elem_dof, ke, ierr) + if (ierr .ne. FEM_SUCCESS) call fail(21) + if (n_elem_dof .ne. 24) call fail(22) + if (elem_dofs(1) .ne. 1 .or. elem_dofs(24) .ne. 24) call fail(23) + call check_symmetric(ke, n_elem_dof, 24) + call check_rigid_translation(ke, n_elem_dof, 1, 25) + call check_rigid_translation(ke, n_elem_dof, 2, 26) + call check_rigid_translation(ke, n_elem_dof, 3, 27) + call check_positive_energy(ke, n_elem_dof, 28) + + call database_finalize(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(29) + end subroutine check_c3d8_stiff + + subroutine check_bad_stiff_type() + integer :: ierr + integer :: elem_dofs(MAX_TEST_DOF) + integer :: n_elem_dof + real(rk) :: ke(MAX_TEST_DOF,MAX_TEST_DOF) + + call database_allocate_model(10, 1, 0, 0, 0, 0, 1, 0, 0, & + 0, 0, 0, 0, 0, ierr) + if (ierr .ne. FEM_SUCCESS) call fail(40) + call fill_node_ids(10) + elem_id_ext(1) = 1 + elem_type(1) = 'C3D10' + elem_nnode(1) = 10 + elem_conn(:,1) = 0 + elem_conn(1:10,1) = (/ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /) + elem_mat(1) = 1 + mat_e(1) = 30.0_rk + mat_nu(1) = 0.25_rk + call database_assign_dofs(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(41) + + call element_linear_stiffness(1, elem_dofs, n_elem_dof, ke, ierr) + if (ierr .eq. FEM_SUCCESS) call fail(42) + + call database_finalize(ierr) + if (ierr .ne. FEM_SUCCESS) call fail(43) + end subroutine check_bad_stiff_type + + subroutine setup_c3d4(ierr) + integer, intent(out) :: ierr + + call database_allocate_model(4, 1, 0, 0, 0, 0, 1, 0, 0, & + 0, 0, 0, 0, 0, ierr) + if (ierr .ne. FEM_SUCCESS) return + call fill_node_ids(4) + + coord0(:,1) = (/ ZERO, ZERO, ZERO /) + 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 + mat_e(1) = 30.0_rk + mat_nu(1) = 0.25_rk + + call database_assign_dofs(ierr) + end subroutine setup_c3d4 + + subroutine setup_c3d8(ierr) + integer, intent(out) :: ierr + + call database_allocate_model(8, 1, 0, 0, 0, 0, 1, 0, 0, & + 0, 0, 0, 0, 0, ierr) + if (ierr .ne. FEM_SUCCESS) return + call fill_node_ids(8) + + coord0(:,1) = (/ ZERO, ZERO, ZERO /) + coord0(:,2) = (/ ONE, ZERO, ZERO /) + coord0(:,3) = (/ ONE, ONE, ZERO /) + coord0(:,4) = (/ ZERO, ONE, ZERO /) + coord0(:,5) = (/ ZERO, ZERO, ONE /) + coord0(:,6) = (/ ONE, ZERO, ONE /) + coord0(:,7) = (/ ONE, ONE, ONE /) + coord0(:,8) = (/ ZERO, ONE, ONE /) + + elem_id_ext(1) = 1 + elem_type(1) = 'C3D8' + elem_nnode(1) = 8 + elem_conn(:,1) = 0 + elem_conn(1:8,1) = (/ 1, 2, 3, 4, 5, 6, 7, 8 /) + elem_mat(1) = 1 + mat_e(1) = 30.0_rk + mat_nu(1) = 0.25_rk + + call database_assign_dofs(ierr) + end subroutine setup_c3d8 + + subroutine fill_node_ids(count) + integer, intent(in) :: count + integer :: i + + do i = 1, count + node_id_ext(i) = i + coord0(:,i) = ZERO + coord(:,i) = ZERO + end do + end subroutine fill_node_ids + + subroutine check_symmetric(ke, n, code) + real(rk), intent(in) :: ke(MAX_TEST_DOF,MAX_TEST_DOF) + integer, intent(in) :: n + integer, intent(in) :: code + integer :: i + integer :: j + + do i = 1, n + do j = 1, n + if (abs(ke(i,j) - ke(j,i)) .gt. TOL) call fail(code) + end do + end do + end subroutine check_symmetric + + subroutine check_rigid_translation(ke, n, idir, code) + real(rk), intent(in) :: ke(MAX_TEST_DOF,MAX_TEST_DOF) + integer, intent(in) :: n + integer, intent(in) :: idir + integer, intent(in) :: code + real(rk) :: x(MAX_TEST_DOF) + real(rk) :: y(MAX_TEST_DOF) + integer :: i + + x = ZERO + y = ZERO + do i = idir, n, NDIM + x(i) = ONE + end do + y(1:n) = matmul(ke(1:n,1:n), x(1:n)) + if (maxval(abs(y(1:n))) .gt. TOL) call fail(code) + end subroutine check_rigid_translation + + subroutine check_positive_energy(ke, n, code) + real(rk), intent(in) :: ke(MAX_TEST_DOF,MAX_TEST_DOF) + integer, intent(in) :: n + integer, intent(in) :: code + real(rk) :: x(MAX_TEST_DOF) + real(rk) :: y(MAX_TEST_DOF) + + x = ZERO + y = ZERO + x(n) = ONE + y(1:n) = matmul(ke(1:n,1:n), x(1:n)) + if (dot_product(x(1:n), y(1:n)) .le. TOL) call fail(code) + end subroutine check_positive_energy + + subroutine fail(code) + integer, intent(in) :: code + + write(*,*) 'test_element_stiffness failed:', code + stop 1 + end subroutine fail + +end program test_element_stiffness