938 lines
29 KiB
Fortran
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
|