module fem_element_internal use fem_precision use fem_error use fem_database use fem_element_topology use fem_element_state use fem_quadrature use fem_shape_functions use fem_material_j2 implicit none contains subroutine element_compute_internal_force(ierr, dt) integer, intent(out) :: ierr real(rk), intent(in), optional :: dt integer :: elem real(rk) :: dt_local if (.not. allocated(fint)) then call error_set(FEM_ERR_INTERNAL, 'internal force vector is not allocated', ierr) return end if call element_state_ensure(ierr) if (ierr .ne. FEM_SUCCESS) return dt_local = ZERO if (present(dt)) dt_local = dt fint = ZERO do elem = 1, nelem if (elem_status(elem) .ne. 0) cycle select case (trim(adjustl(elem_type(elem)))) case ('C3D4') call c3d4_internal_force(elem, dt_local, ierr) if (ierr .ne. FEM_SUCCESS) return case ('C3D8') call c3d8_internal_force(elem, dt_local, ierr) if (ierr .ne. FEM_SUCCESS) return case ('C3D10', 'C3D20') call solid_quadratic_internal_force(elem, dt_local, ierr) if (ierr .ne. FEM_SUCCESS) return case ('S4') call shell4_internal_force(elem, ierr) if (ierr .ne. FEM_SUCCESS) return case default cycle end select end do ierr = FEM_SUCCESS end subroutine element_compute_internal_force subroutine c3d4_internal_force(elem, dt, ierr) integer, intent(in) :: elem real(rk), intent(in) :: dt integer, intent(out) :: ierr real(rk) :: dndx(NDIM,4) real(rk) :: eps(NSTRESS) real(rk) :: deps(NSTRESS) real(rk) :: sig(NSTRESS) real(rk) :: state_old(NSTATEV_MAX) real(rk) :: state_new(NSTATEV_MAX) real(rk) :: stress_old(NSTRESS) real(rk) :: spin_current(3) real(rk) :: spin_inc(3) real(rk) :: volume integer :: local_node integer :: node integer :: dof integer :: gp call c3d4_shape_gradients(elem, dndx, volume, ierr) if (ierr .ne. FEM_SUCCESS) return eps = ZERO do local_node = 1, 4 node = elem_conn(local_node, elem) eps(1) = eps(1) + dndx(1,local_node) * get_dof_value(u, 1, node) eps(2) = eps(2) + dndx(2,local_node) * get_dof_value(u, 2, node) eps(3) = eps(3) + dndx(3,local_node) * get_dof_value(u, 3, node) eps(4) = eps(4) + dndx(2,local_node) * get_dof_value(u, 1, node) + & dndx(1,local_node) * get_dof_value(u, 2, node) eps(5) = eps(5) + dndx(3,local_node) * get_dof_value(u, 1, node) + & dndx(1,local_node) * get_dof_value(u, 3, node) eps(6) = eps(6) + dndx(3,local_node) * get_dof_value(u, 2, node) + & dndx(2,local_node) * get_dof_value(u, 3, node) end do gp = elem_gp_start(elem) deps = eps stress_old = ZERO state_old = ZERO if (gp .gt. 0) then deps = eps - strain(:,gp) stress_old = stress(:,gp) state_old = statev(:,gp) end if call solid_current_spin(elem, 4, dndx, spin_current) spin_inc = spin_current - state_old(14:16) call material_update_small_strain_dt(elem_mat(elem), dt, deps, state_old, & stress_old, sig, state_new, ierr, spin_inc) if (ierr .ne. FEM_SUCCESS) return state_new(14:16) = spin_current if (gp .gt. 0) then strain(:,gp) = eps stress(:,gp) = sig statev(:,gp) = state_new if (state_new(4) .ge. HALF) then elem_status(elem) = 1 stress(:,gp) = ZERO return end if end if do local_node = 1, 4 node = elem_conn(local_node, elem) dof = dof_id(1,node) if (dof .gt. 0) then fint(dof) = fint(dof) + volume * & (dndx(1,local_node) * sig(1) + dndx(2,local_node) * sig(4) + & dndx(3,local_node) * sig(5)) end if dof = dof_id(2,node) if (dof .gt. 0) then fint(dof) = fint(dof) + volume * & (dndx(1,local_node) * sig(4) + dndx(2,local_node) * sig(2) + & dndx(3,local_node) * sig(6)) end if dof = dof_id(3,node) if (dof .gt. 0) then fint(dof) = fint(dof) + volume * & (dndx(1,local_node) * sig(5) + dndx(2,local_node) * sig(6) + & dndx(3,local_node) * sig(3)) end if end do ierr = FEM_SUCCESS end subroutine c3d4_internal_force subroutine c3d8_internal_force(elem, dt, ierr) integer, intent(in) :: elem real(rk), intent(in) :: dt integer, intent(out) :: ierr real(rk) :: gp_nat(NDIM,8) real(rk) :: gp_weight(8) real(rk) :: dndr(NDIM,8) real(rk) :: dndx(NDIM,8) real(rk) :: detj real(rk) :: eps(NSTRESS) real(rk) :: deps(NSTRESS) real(rk) :: sig(NSTRESS) real(rk) :: state_old(NSTATEV_MAX) real(rk) :: state_new(NSTATEV_MAX) real(rk) :: stress_old(NSTRESS) real(rk) :: spin_current(3) real(rk) :: spin_inc(3) real(rk) :: local_force(NDIM,8) real(rk) :: r real(rk) :: s real(rk) :: t real(rk) :: weight integer :: q integer :: npoint integer :: local_node integer :: node integer :: gp integer :: gp_start integer :: failed_count integer :: dof if (elem_nnode(elem) .ne. 8) then call error_set(FEM_ERR_MESH, 'C3D8 element must have 8 nodes', ierr) return end if call quadrature_get_rule('C3D8', 8, npoint, gp_nat, gp_weight, ierr) if (ierr .ne. FEM_SUCCESS) return gp_start = elem_gp_start(elem) gp = gp_start failed_count = 0 local_force = ZERO do q = 1, npoint r = gp_nat(1,q) s = gp_nat(2,q) t = gp_nat(3,q) weight = gp_weight(q) call hex8_shape_gradients(elem, r, s, t, dndr, dndx, detj, ierr) if (ierr .ne. FEM_SUCCESS) return eps = ZERO do local_node = 1, 8 node = elem_conn(local_node, elem) eps(1) = eps(1) + dndx(1,local_node) * get_dof_value(u, 1, node) eps(2) = eps(2) + dndx(2,local_node) * get_dof_value(u, 2, node) eps(3) = eps(3) + dndx(3,local_node) * get_dof_value(u, 3, node) eps(4) = eps(4) + dndx(2,local_node) * get_dof_value(u, 1, node) + & dndx(1,local_node) * get_dof_value(u, 2, node) eps(5) = eps(5) + dndx(3,local_node) * get_dof_value(u, 1, node) + & dndx(1,local_node) * get_dof_value(u, 3, node) eps(6) = eps(6) + dndx(3,local_node) * get_dof_value(u, 2, node) + & dndx(2,local_node) * get_dof_value(u, 3, node) end do deps = eps stress_old = ZERO state_old = ZERO if (gp .gt. 0) then deps = eps - strain(:,gp) stress_old = stress(:,gp) state_old = statev(:,gp) end if call solid_current_spin(elem, 8, dndx, spin_current) spin_inc = spin_current - state_old(14:16) call material_update_small_strain_dt(elem_mat(elem), dt, deps, & state_old, stress_old, sig, & state_new, ierr, spin_inc) if (ierr .ne. FEM_SUCCESS) return state_new(14:16) = spin_current if (gp .gt. 0) then strain(:,gp) = eps stress(:,gp) = sig statev(:,gp) = state_new if (state_new(4) .ge. HALF) failed_count = failed_count + 1 end if do local_node = 1, 8 node = elem_conn(local_node, elem) dof = dof_id(1,node) if (dof .gt. 0) then local_force(1,local_node) = local_force(1,local_node) + weight * detj * & (dndx(1,local_node) * sig(1) + dndx(2,local_node) * sig(4) + & dndx(3,local_node) * sig(5)) end if dof = dof_id(2,node) if (dof .gt. 0) then local_force(2,local_node) = local_force(2,local_node) + weight * detj * & (dndx(1,local_node) * sig(4) + dndx(2,local_node) * sig(2) + & dndx(3,local_node) * sig(6)) end if dof = dof_id(3,node) if (dof .gt. 0) then local_force(3,local_node) = local_force(3,local_node) + weight * detj * & (dndx(1,local_node) * sig(5) + dndx(2,local_node) * sig(6) + & dndx(3,local_node) * sig(3)) end if end do gp = gp + 1 end do if (failed_count .ge. 4) then elem_status(elem) = 1 if (gp_start .gt. 0) stress(:,gp_start:gp_start+7) = ZERO else do local_node = 1, 8 node = elem_conn(local_node, elem) dof = dof_id(1,node) if (dof .gt. 0) fint(dof) = fint(dof) + local_force(1,local_node) dof = dof_id(2,node) if (dof .gt. 0) fint(dof) = fint(dof) + local_force(2,local_node) dof = dof_id(3,node) if (dof .gt. 0) fint(dof) = fint(dof) + local_force(3,local_node) end do end if ierr = FEM_SUCCESS end subroutine c3d8_internal_force subroutine solid_quadratic_internal_force(elem, dt, ierr) integer, intent(in) :: elem real(rk), intent(in) :: dt integer, intent(out) :: ierr integer, parameter :: MAX_QP = 32 real(rk) :: gp_nat(NDIM,MAX_QP) real(rk) :: gp_weight(MAX_QP) real(rk) :: nshape(MAX_NEN) real(rk) :: dndr(NDIM,MAX_NEN) real(rk) :: dndx(NDIM,MAX_NEN) real(rk) :: detj real(rk) :: eps(NSTRESS) real(rk) :: deps(NSTRESS) real(rk) :: sig(NSTRESS) real(rk) :: state_old(NSTATEV_MAX) real(rk) :: state_new(NSTATEV_MAX) real(rk) :: stress_old(NSTRESS) real(rk) :: spin_current(3) real(rk) :: spin_inc(3) real(rk) :: local_force(NDIM,MAX_NEN) real(rk) :: factor integer :: q integer :: npoint integer :: nlocal integer :: local_node integer :: node integer :: gp integer :: gp_start integer :: failed_count integer :: dof nlocal = elem_nnode(elem) call element_validate_node_count(elem_type(elem), nlocal, ierr) if (ierr .ne. FEM_SUCCESS) return call quadrature_get_rule(elem_type(elem), MAX_QP, npoint, gp_nat, gp_weight, ierr) if (ierr .ne. FEM_SUCCESS) return gp_start = elem_gp_start(elem) gp = gp_start failed_count = 0 local_force = ZERO do q = 1, npoint call shape_evaluate(elem_type(elem), gp_nat(:,q), nshape, dndr, ierr) if (ierr .ne. FEM_SUCCESS) return call solid_shape_gradients(elem, nlocal, dndr, dndx, detj, ierr) if (ierr .ne. FEM_SUCCESS) return call solid_strain_from_dndx(elem, nlocal, dndx, eps) deps = eps stress_old = ZERO state_old = ZERO if (gp .gt. 0) then deps = eps - strain(:,gp) stress_old = stress(:,gp) state_old = statev(:,gp) end if call solid_current_spin(elem, nlocal, dndx, spin_current) spin_inc = spin_current - state_old(14:16) call material_update_small_strain_dt(elem_mat(elem), dt, deps, & state_old, stress_old, sig, & state_new, ierr, spin_inc) if (ierr .ne. FEM_SUCCESS) return state_new(14:16) = spin_current if (gp .gt. 0) then strain(:,gp) = eps stress(:,gp) = sig statev(:,gp) = state_new if (state_new(4) .ge. HALF) failed_count = failed_count + 1 end if factor = gp_weight(q) * detj do local_node = 1, nlocal local_force(1,local_node) = local_force(1,local_node) + factor * & (dndx(1,local_node) * sig(1) + dndx(2,local_node) * sig(4) + & dndx(3,local_node) * sig(5)) local_force(2,local_node) = local_force(2,local_node) + factor * & (dndx(1,local_node) * sig(4) + dndx(2,local_node) * sig(2) + & dndx(3,local_node) * sig(6)) local_force(3,local_node) = local_force(3,local_node) + factor * & (dndx(1,local_node) * sig(5) + dndx(2,local_node) * sig(6) + & dndx(3,local_node) * sig(3)) end do gp = gp + 1 end do if (should_delete_solid(elem_type(elem), failed_count, npoint)) then elem_status(elem) = 1 if (gp_start .gt. 0) stress(:,gp_start:gp_start+npoint-1) = ZERO else do local_node = 1, nlocal node = elem_conn(local_node, elem) dof = dof_id(1,node) if (dof .gt. 0) fint(dof) = fint(dof) + local_force(1,local_node) dof = dof_id(2,node) if (dof .gt. 0) fint(dof) = fint(dof) + local_force(2,local_node) dof = dof_id(3,node) if (dof .gt. 0) fint(dof) = fint(dof) + local_force(3,local_node) end do end if ierr = FEM_SUCCESS end subroutine solid_quadratic_internal_force subroutine shell4_internal_force(elem, ierr) integer, intent(in) :: elem integer, intent(out) :: ierr real(rk) :: basis(NDIM,NDIM) real(rk) :: xloc(2,4) real(rk) :: qloc(5,4) real(rk) :: floc(5,4) real(rk) :: gp_nat(NDIM,4) real(rk) :: gp_weight(4) real(rk) :: nshape(4) real(rk) :: dndx(4) real(rk) :: dndy(4) real(rk) :: strain_mem(3) real(rk) :: strain_ben(3) real(rk) :: strain_shr(2) real(rk) :: force_mem(3) real(rk) :: force_ben(3) real(rk) :: force_shr(2) real(rk) :: young real(rk) :: poisson real(rk) :: thickness real(rk) :: shear_mod real(rk) :: coeff_mem real(rk) :: coeff_ben real(rk) :: coeff_shr real(rk) :: detj real(rk) :: weight real(rk) :: r real(rk) :: s integer :: q integer :: npoint integer :: gp integer :: gp_start integer :: local_node integer :: mat integer :: sec if (elem_nnode(elem) .ne. 4) then call error_set(FEM_ERR_MESH, 'S4 element must have 4 nodes', ierr) return end if mat = elem_mat(elem) sec = elem_sec(elem) if (mat .lt. 1 .or. mat .gt. n_material) then call error_set(FEM_ERR_MATERIAL, 'S4 element has invalid material index', ierr) return end if if (sec .lt. 1 .or. sec .gt. n_section) then call error_set(FEM_ERR_INPUT, 'S4 element has invalid section index', ierr) return end if young = mat_e(mat) poisson = mat_nu(mat) thickness = section_thickness(sec) if (young .le. ZERO) then call error_set(FEM_ERR_MATERIAL, 'S4 elastic modulus must be positive', ierr) return end if if (poisson .le. -ONE .or. poisson .ge. HALF) then call error_set(FEM_ERR_MATERIAL, 'S4 Poisson ratio must be in (-1,0.5)', ierr) return end if if (thickness .le. ZERO) then call error_set(FEM_ERR_INPUT, 'S4 section thickness must be positive', ierr) return end if call shell4_basis(elem, basis, xloc, ierr) if (ierr .ne. FEM_SUCCESS) return call shell4_local_dofs(elem, basis, qloc) shear_mod = young / (2.0_rk * (ONE + poisson)) coeff_mem = young * thickness / (ONE - poisson * poisson) coeff_ben = young * thickness**3 / & (12.0_rk * (ONE - poisson * poisson)) coeff_shr = (5.0_rk / 6.0_rk) * shear_mod * thickness call quadrature_get_rule('S4', 4, npoint, gp_nat, gp_weight, ierr) if (ierr .ne. FEM_SUCCESS) return gp_start = elem_gp_start(elem) gp = gp_start floc = ZERO do q = 1, npoint r = gp_nat(1,q) s = gp_nat(2,q) call shell4_shape_xy(xloc, r, s, nshape, dndx, dndy, detj, ierr) if (ierr .ne. FEM_SUCCESS) return weight = gp_weight(q) * detj call shell4_strains(nshape, dndx, dndy, qloc, strain_mem, & strain_ben, strain_shr) call shell4_resultants(coeff_mem, coeff_ben, coeff_shr, poisson, & strain_mem, strain_ben, strain_shr, & force_mem, force_ben, force_shr) do local_node = 1, 4 floc(1,local_node) = floc(1,local_node) + weight * & (dndx(local_node) * force_mem(1) + & dndy(local_node) * force_mem(3)) floc(2,local_node) = floc(2,local_node) + weight * & (dndy(local_node) * force_mem(2) + & dndx(local_node) * force_mem(3)) floc(3,local_node) = floc(3,local_node) + weight * & (dndx(local_node) * force_shr(1) + & dndy(local_node) * force_shr(2)) floc(4,local_node) = floc(4,local_node) + weight * & (-dndy(local_node) * force_ben(2) - & dndx(local_node) * force_ben(3) - & nshape(local_node) * force_shr(2)) floc(5,local_node) = floc(5,local_node) + weight * & (dndx(local_node) * force_ben(1) + & dndy(local_node) * force_ben(3) + & nshape(local_node) * force_shr(1)) end do if (gp .gt. 0) then strain(:,gp) = ZERO stress(:,gp) = ZERO statev(:,gp) = ZERO strain(1,gp) = strain_mem(1) strain(2,gp) = strain_mem(2) strain(4,gp) = strain_mem(3) strain(5,gp) = strain_shr(1) strain(6,gp) = strain_shr(2) stress(1,gp) = force_mem(1) / thickness stress(2,gp) = force_mem(2) / thickness stress(4,gp) = force_mem(3) / thickness stress(5,gp) = force_shr(1) / thickness stress(6,gp) = force_shr(2) / thickness statev(10,gp) = strain_ben(1) statev(11,gp) = strain_ben(2) statev(12,gp) = strain_ben(3) end if gp = gp + 1 end do call shell4_add_global(elem, basis, floc) ierr = FEM_SUCCESS end subroutine shell4_internal_force subroutine shell4_basis(elem, basis, xloc, ierr) integer, intent(in) :: elem real(rk), intent(out) :: basis(NDIM,NDIM) real(rk), intent(out) :: xloc(2,4) integer, intent(out) :: ierr real(rk) :: origin(NDIM) real(rk) :: x1(NDIM) real(rk) :: x2(NDIM) real(rk) :: x3(NDIM) real(rk) :: x4(NDIM) real(rk) :: v12(NDIM) real(rk) :: v14(NDIM) real(rk) :: normal(NDIM) real(rk) :: tmp(NDIM) real(rk) :: len1 real(rk) :: lenn integer :: local_node integer :: node x1 = coord0(:, elem_conn(1,elem)) x2 = coord0(:, elem_conn(2,elem)) x3 = coord0(:, elem_conn(3,elem)) x4 = coord0(:, elem_conn(4,elem)) origin = x1 v12 = x2 - x1 v14 = x4 - x1 len1 = sqrt(sum(v12 * v12)) if (len1 .le. ZERO) then call error_set(FEM_ERR_MESH, 'S4 has coincident first edge nodes', ierr) return end if basis(:,1) = v12 / len1 call cross3(v12, v14, normal) lenn = sqrt(sum(normal * normal)) if (lenn .le. ZERO) then tmp = x3 - x1 call cross3(v12, tmp, normal) lenn = sqrt(sum(normal * normal)) end if if (lenn .le. ZERO) then call error_set(FEM_ERR_MESH, 'S4 local basis is singular', ierr) return end if basis(:,3) = normal / lenn call cross3(basis(:,3), basis(:,1), basis(:,2)) do local_node = 1, 4 node = elem_conn(local_node, elem) tmp = coord0(:,node) - origin xloc(1,local_node) = dot_product(tmp, basis(:,1)) xloc(2,local_node) = dot_product(tmp, basis(:,2)) end do ierr = FEM_SUCCESS end subroutine shell4_basis subroutine shell4_local_dofs(elem, basis, qloc) integer, intent(in) :: elem real(rk), intent(in) :: basis(NDIM,NDIM) real(rk), intent(out) :: qloc(5,4) real(rk) :: disp(NDIM) real(rk) :: rot(NDIM) integer :: local_node integer :: node integer :: idir integer :: dof qloc = ZERO do local_node = 1, 4 node = elem_conn(local_node, elem) disp = ZERO rot = ZERO do idir = 1, NDIM dof = dof_id(idir,node) if (dof .gt. 0) disp(idir) = u(dof) dof = dof_id(idir + 3,node) if (dof .gt. 0) rot(idir) = u(dof) end do qloc(1,local_node) = dot_product(disp, basis(:,1)) qloc(2,local_node) = dot_product(disp, basis(:,2)) qloc(3,local_node) = dot_product(disp, basis(:,3)) qloc(4,local_node) = dot_product(rot, basis(:,1)) qloc(5,local_node) = dot_product(rot, basis(:,2)) end do end subroutine shell4_local_dofs subroutine shell4_shape_xy(xloc, r, s, nshape, dndx, dndy, detj, ierr) real(rk), intent(in) :: xloc(2,4) real(rk), intent(in) :: r real(rk), intent(in) :: s real(rk), intent(out) :: nshape(4) real(rk), intent(out) :: dndx(4) real(rk), intent(out) :: dndy(4) real(rk), intent(out) :: detj integer, intent(out) :: ierr real(rk) :: dndr(4) real(rk) :: dnds(4) real(rk) :: jac(2,2) real(rk) :: invj(2,2) integer :: local_node nshape(1) = 0.25_rk * (ONE - r) * (ONE - s) nshape(2) = 0.25_rk * (ONE + r) * (ONE - s) nshape(3) = 0.25_rk * (ONE + r) * (ONE + s) nshape(4) = 0.25_rk * (ONE - r) * (ONE + s) dndr(1) = -0.25_rk * (ONE - s) dndr(2) = 0.25_rk * (ONE - s) dndr(3) = 0.25_rk * (ONE + s) dndr(4) = -0.25_rk * (ONE + s) dnds(1) = -0.25_rk * (ONE - r) dnds(2) = -0.25_rk * (ONE + r) dnds(3) = 0.25_rk * (ONE + r) dnds(4) = 0.25_rk * (ONE - r) jac = ZERO do local_node = 1, 4 jac(1,1) = jac(1,1) + xloc(1,local_node) * dndr(local_node) jac(1,2) = jac(1,2) + xloc(1,local_node) * dnds(local_node) jac(2,1) = jac(2,1) + xloc(2,local_node) * dndr(local_node) jac(2,2) = jac(2,2) + xloc(2,local_node) * dnds(local_node) end do detj = jac(1,1) * jac(2,2) - jac(1,2) * jac(2,1) if (detj .le. ZERO) then call error_set(FEM_ERR_MESH, 'S4 element has non-positive Jacobian', ierr) return end if invj(1,1) = jac(2,2) / detj invj(1,2) = -jac(1,2) / detj invj(2,1) = -jac(2,1) / detj invj(2,2) = jac(1,1) / detj do local_node = 1, 4 dndx(local_node) = dndr(local_node) * invj(1,1) + & dnds(local_node) * invj(2,1) dndy(local_node) = dndr(local_node) * invj(1,2) + & dnds(local_node) * invj(2,2) end do ierr = FEM_SUCCESS end subroutine shell4_shape_xy subroutine shell4_strains(nshape, dndx, dndy, qloc, strain_mem, & strain_ben, strain_shr) real(rk), intent(in) :: nshape(4) real(rk), intent(in) :: dndx(4) real(rk), intent(in) :: dndy(4) real(rk), intent(in) :: qloc(5,4) real(rk), intent(out) :: strain_mem(3) real(rk), intent(out) :: strain_ben(3) real(rk), intent(out) :: strain_shr(2) integer :: local_node strain_mem = ZERO strain_ben = ZERO strain_shr = ZERO do local_node = 1, 4 strain_mem(1) = strain_mem(1) + dndx(local_node) * qloc(1,local_node) strain_mem(2) = strain_mem(2) + dndy(local_node) * qloc(2,local_node) strain_mem(3) = strain_mem(3) + dndy(local_node) * qloc(1,local_node) + & dndx(local_node) * qloc(2,local_node) strain_ben(1) = strain_ben(1) + dndx(local_node) * qloc(5,local_node) strain_ben(2) = strain_ben(2) - dndy(local_node) * qloc(4,local_node) strain_ben(3) = strain_ben(3) - dndx(local_node) * qloc(4,local_node) + & dndy(local_node) * qloc(5,local_node) strain_shr(1) = strain_shr(1) + dndx(local_node) * qloc(3,local_node) + & nshape(local_node) * qloc(5,local_node) strain_shr(2) = strain_shr(2) + dndy(local_node) * qloc(3,local_node) - & nshape(local_node) * qloc(4,local_node) end do end subroutine shell4_strains subroutine shell4_resultants(coeff_mem, coeff_ben, coeff_shr, poisson, & strain_mem, strain_ben, strain_shr, & force_mem, force_ben, force_shr) real(rk), intent(in) :: coeff_mem real(rk), intent(in) :: coeff_ben real(rk), intent(in) :: coeff_shr real(rk), intent(in) :: poisson real(rk), intent(in) :: strain_mem(3) real(rk), intent(in) :: strain_ben(3) real(rk), intent(in) :: strain_shr(2) real(rk), intent(out) :: force_mem(3) real(rk), intent(out) :: force_ben(3) real(rk), intent(out) :: force_shr(2) force_mem(1) = coeff_mem * (strain_mem(1) + poisson * strain_mem(2)) force_mem(2) = coeff_mem * (poisson * strain_mem(1) + strain_mem(2)) force_mem(3) = coeff_mem * HALF * (ONE - poisson) * strain_mem(3) force_ben(1) = coeff_ben * (strain_ben(1) + poisson * strain_ben(2)) force_ben(2) = coeff_ben * (poisson * strain_ben(1) + strain_ben(2)) force_ben(3) = coeff_ben * HALF * (ONE - poisson) * strain_ben(3) force_shr(1) = coeff_shr * strain_shr(1) force_shr(2) = coeff_shr * strain_shr(2) end subroutine shell4_resultants subroutine shell4_add_global(elem, basis, floc) integer, intent(in) :: elem real(rk), intent(in) :: basis(NDIM,NDIM) real(rk), intent(in) :: floc(5,4) real(rk) :: fglob(NDIM) real(rk) :: mglob(NDIM) integer :: local_node integer :: node integer :: idir integer :: dof do local_node = 1, 4 node = elem_conn(local_node, elem) fglob = floc(1,local_node) * basis(:,1) + & floc(2,local_node) * basis(:,2) + & floc(3,local_node) * basis(:,3) mglob = floc(4,local_node) * basis(:,1) + & floc(5,local_node) * basis(:,2) do idir = 1, NDIM dof = dof_id(idir,node) if (dof .gt. 0) fint(dof) = fint(dof) + fglob(idir) dof = dof_id(idir + 3,node) if (dof .gt. 0) fint(dof) = fint(dof) + mglob(idir) end do end do end subroutine shell4_add_global subroutine solid_shape_gradients(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, 'solid 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 solid_shape_gradients subroutine solid_strain_from_dndx(elem, nlocal, dndx, eps) integer, intent(in) :: elem integer, intent(in) :: nlocal real(rk), intent(in) :: dndx(NDIM,MAX_NEN) real(rk), intent(out) :: eps(NSTRESS) integer :: local_node integer :: node eps = ZERO do local_node = 1, nlocal node = elem_conn(local_node, elem) eps(1) = eps(1) + dndx(1,local_node) * get_dof_value(u, 1, node) eps(2) = eps(2) + dndx(2,local_node) * get_dof_value(u, 2, node) eps(3) = eps(3) + dndx(3,local_node) * get_dof_value(u, 3, node) eps(4) = eps(4) + dndx(2,local_node) * get_dof_value(u, 1, node) + & dndx(1,local_node) * get_dof_value(u, 2, node) eps(5) = eps(5) + dndx(3,local_node) * get_dof_value(u, 1, node) + & dndx(1,local_node) * get_dof_value(u, 3, node) eps(6) = eps(6) + dndx(3,local_node) * get_dof_value(u, 2, node) + & dndx(2,local_node) * get_dof_value(u, 3, node) end do end subroutine solid_strain_from_dndx logical function should_delete_solid(etype, failed_count, npoint) character(len=*), intent(in) :: etype integer, intent(in) :: failed_count integer, intent(in) :: npoint character(len=ELEM_TYPE_LEN) :: local_type local_type = adjustl(etype) if (failed_count .le. 0) then should_delete_solid = .false. else if (trim(local_type) .eq. 'C3D4' .or. trim(local_type) .eq. 'C3D10') then should_delete_solid = .true. else should_delete_solid = failed_count * 2 .ge. npoint end if end function should_delete_solid subroutine solid_current_spin(elem, nlocal, dndx, spin_current) integer, intent(in) :: elem integer, intent(in) :: nlocal real(rk), intent(in) :: dndx(NDIM,nlocal) real(rk), intent(out) :: spin_current(3) real(rk) :: gradu(NDIM,NDIM) integer :: local_node integer :: node integer :: idir integer :: jdir gradu = ZERO do local_node = 1, nlocal node = elem_conn(local_node, elem) do idir = 1, NDIM do jdir = 1, NDIM gradu(idir,jdir) = gradu(idir,jdir) + & get_dof_value(u, idir, node) * dndx(jdir,local_node) end do end do end do spin_current(1) = HALF * (gradu(1,2) - gradu(2,1)) spin_current(2) = HALF * (gradu(1,3) - gradu(3,1)) spin_current(3) = HALF * (gradu(2,3) - gradu(3,2)) end subroutine solid_current_spin subroutine elastic_stress_3d(mat, eps, sig, ierr) integer, intent(in) :: mat real(rk), intent(in) :: eps(NSTRESS) real(rk), intent(out) :: sig(NSTRESS) integer, intent(out) :: ierr real(rk) :: lambda real(rk) :: mu real(rk) :: trace_eps real(rk) :: young real(rk) :: poisson if (mat .lt. 1 .or. mat .gt. n_material) then call error_set(FEM_ERR_MATERIAL, 'invalid material index for elastic stress', ierr) return end if young = mat_e(mat) poisson = mat_nu(mat) if (young .le. ZERO) then call error_set(FEM_ERR_MATERIAL, 'elastic modulus must be positive', ierr) return end if if (poisson .le. -ONE .or. poisson .ge. HALF) then call error_set(FEM_ERR_MATERIAL, '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)) trace_eps = eps(1) + eps(2) + eps(3) sig(1) = lambda * trace_eps + 2.0_rk * mu * eps(1) sig(2) = lambda * trace_eps + 2.0_rk * mu * eps(2) sig(3) = lambda * trace_eps + 2.0_rk * mu * eps(3) sig(4) = mu * eps(4) sig(5) = mu * eps(5) sig(6) = mu * eps(6) ierr = FEM_SUCCESS end subroutine elastic_stress_3d subroutine c3d4_shape_gradients(elem, dndx, volume, ierr) integer, intent(in) :: elem real(rk), intent(out) :: dndx(NDIM,4) real(rk), intent(out) :: volume integer, intent(out) :: ierr real(rk) :: x1(NDIM) real(rk) :: x2(NDIM) real(rk) :: x3(NDIM) real(rk) :: x4(NDIM) real(rk) :: jac(3,3) real(rk) :: invj(3,3) real(rk) :: detj real(rk) :: dndr(3,4) integer :: local_node integer :: i integer :: j if (elem_nnode(elem) .ne. 4) then call error_set(FEM_ERR_MESH, 'C3D4 element must have 4 nodes', ierr) return end if x1 = coord0(:, elem_conn(1,elem)) x2 = coord0(:, elem_conn(2,elem)) x3 = coord0(:, elem_conn(3,elem)) x4 = coord0(:, elem_conn(4,elem)) jac(:,1) = x2 - x1 jac(:,2) = x3 - x1 jac(:,3) = x4 - x1 call inverse3(jac, invj, detj, ierr) if (ierr .ne. FEM_SUCCESS) return if (detj .le. ZERO) then call error_set(FEM_ERR_MESH, 'C3D4 element has non-positive Jacobian', ierr) return end if volume = detj / 6.0_rk dndr(:,1) = (/ -ONE, -ONE, -ONE /) dndr(:,2) = (/ ONE, ZERO, ZERO /) dndr(:,3) = (/ ZERO, ONE, ZERO /) dndr(:,4) = (/ ZERO, ZERO, ONE /) dndx = ZERO do local_node = 1, 4 do i = 1, NDIM do j = 1, NDIM dndx(i,local_node) = dndx(i,local_node) + invj(j,i) * dndr(j,local_node) end do end do end do ierr = FEM_SUCCESS end subroutine c3d4_shape_gradients subroutine hex8_shape_gradients(elem, r, s, t, dndr, dndx, detj, ierr) integer, intent(in) :: elem real(rk), intent(in) :: r real(rk), intent(in) :: s real(rk), intent(in) :: t real(rk), intent(out) :: dndr(NDIM,8) real(rk), intent(out) :: dndx(NDIM,8) real(rk), intent(out) :: detj integer, intent(out) :: ierr real(rk) :: natural(NDIM) real(rk) :: nshape(MAX_NEN) real(rk) :: dndr_all(NDIM,MAX_NEN) real(rk) :: jac(3,3) real(rk) :: invj(3,3) integer :: local_node integer :: node integer :: i integer :: j natural = (/ r, s, t /) call shape_evaluate('C3D8', natural, nshape, dndr_all, ierr) if (ierr .ne. FEM_SUCCESS) return dndr = dndr_all(:,1:8) jac = ZERO do local_node = 1, 8 node = elem_conn(local_node, elem) jac(1,1) = jac(1,1) + coord0(1,node) * dndr(1,local_node) jac(1,2) = jac(1,2) + coord0(1,node) * dndr(2,local_node) jac(1,3) = jac(1,3) + coord0(1,node) * dndr(3,local_node) jac(2,1) = jac(2,1) + coord0(2,node) * dndr(1,local_node) jac(2,2) = jac(2,2) + coord0(2,node) * dndr(2,local_node) jac(2,3) = jac(2,3) + coord0(2,node) * dndr(3,local_node) jac(3,1) = jac(3,1) + coord0(3,node) * dndr(1,local_node) jac(3,2) = jac(3,2) + coord0(3,node) * dndr(2,local_node) jac(3,3) = jac(3,3) + coord0(3,node) * dndr(3,local_node) 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, 'C3D8 element has non-positive Jacobian', ierr) return end if dndx = ZERO do local_node = 1, 8 do i = 1, NDIM do j = 1, NDIM dndx(i,local_node) = dndx(i,local_node) + invj(j,i) * dndr(j,local_node) end do end do end do ierr = FEM_SUCCESS end subroutine hex8_shape_gradients subroutine inverse3(a, ainv, det, ierr) real(rk), intent(in) :: a(3,3) real(rk), intent(out) :: ainv(3,3) 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. ZERO) then call error_set(FEM_ERR_MESH, 'singular 3x3 matrix', 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 subroutine cross3(a, b, c) real(rk), intent(in) :: a(NDIM) real(rk), intent(in) :: b(NDIM) real(rk), intent(out) :: c(NDIM) c(1) = a(2) * b(3) - a(3) * b(2) c(2) = a(3) * b(1) - a(1) * b(3) c(3) = a(1) * b(2) - a(2) * b(1) end subroutine cross3 real(rk) function get_dof_value(vector, dof_num, node) real(rk), intent(in) :: vector(:) integer, intent(in) :: dof_num integer, intent(in) :: node integer :: dof get_dof_value = ZERO dof = dof_id(dof_num,node) if (dof .gt. 0) get_dof_value = vector(dof) end function get_dof_value end module fem_element_internal