Files
FemLite/src/element/fem_element_internal.f90
T

938 lines
29 KiB
Fortran

module fem_element_internal
use fem_precision
use fem_error
use fem_database
use fem_element_topology
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 ensure_element_state(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 ('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 ensure_element_state(ierr)
integer, intent(out) :: ierr
integer :: elem
integer :: gp
integer :: stat
if (allocated(elem_gp_start)) then
ierr = FEM_SUCCESS
return
end if
allocate(elem_gp_start(nelem), elem_ngp(nelem), stat=stat)
if (stat .ne. 0) then
call error_set(FEM_ERR_INTERNAL, 'failed to allocate element state map', ierr)
return
end if
elem_gp_start = 0
elem_ngp = 0
ngauss_total = 0
do elem = 1, nelem
elem_ngp(elem) = element_num_integration_points(elem_type(elem))
if (elem_ngp(elem) .gt. 0) then
elem_gp_start(elem) = ngauss_total + 1
ngauss_total = ngauss_total + elem_ngp(elem)
end if
end do
if (ngauss_total .gt. 0) then
allocate(stress(NSTRESS,ngauss_total), strain(NSTRESS,ngauss_total), &
statev(NSTATEV_MAX,ngauss_total), stat=stat)
if (stat .ne. 0) then
call error_set(FEM_ERR_INTERNAL, 'failed to allocate element state arrays', ierr)
return
end if
stress = ZERO
strain = ZERO
statev = ZERO
end if
do gp = 1, ngauss_total
statev(1,gp) = ZERO
end do
ierr = FEM_SUCCESS
end subroutine ensure_element_state
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 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_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