166 lines
4.6 KiB
Fortran
166 lines
4.6 KiB
Fortran
module fem_api_stable_dt
|
|
use fem_precision
|
|
use fem_error
|
|
use fem_control
|
|
use fem_database
|
|
use fem_element_topology
|
|
implicit none
|
|
|
|
private
|
|
|
|
public :: api_estimate_stable_dt
|
|
|
|
contains
|
|
|
|
subroutine api_estimate_stable_dt(dtcrit, ierr)
|
|
real(rk), intent(out) :: dtcrit
|
|
integer, intent(out) :: ierr
|
|
integer :: elem
|
|
integer :: mat
|
|
real(rk) :: hchar
|
|
real(rk) :: wave_speed
|
|
real(rk) :: elem_dt
|
|
logical :: has_active
|
|
|
|
dtcrit = ZERO
|
|
if (nelem .le. 0) then
|
|
call error_set(FEM_ERR_MESH, &
|
|
'stable time step requires at least one element', ierr)
|
|
return
|
|
end if
|
|
|
|
elem_dt = huge(ONE)
|
|
has_active = .false.
|
|
do elem = 1, nelem
|
|
if (elem_status(elem) .ne. 0) cycle
|
|
has_active = .true.
|
|
|
|
mat = elem_mat(elem)
|
|
call estimate_material_wave_speed(mat, wave_speed, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call estimate_element_hchar(elem, hchar, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
elem_dt = min(elem_dt, hchar / wave_speed)
|
|
end do
|
|
|
|
if (.not. has_active) then
|
|
dtcrit = ZERO
|
|
else
|
|
dtcrit = stable_dt_safety * elem_dt
|
|
end if
|
|
dt_stable = dtcrit
|
|
ierr = FEM_SUCCESS
|
|
end subroutine api_estimate_stable_dt
|
|
|
|
subroutine estimate_material_wave_speed(mat, wave_speed, ierr)
|
|
integer, intent(in) :: mat
|
|
real(rk), intent(out) :: wave_speed
|
|
integer, intent(out) :: ierr
|
|
real(rk) :: lambda
|
|
real(rk) :: mu
|
|
|
|
wave_speed = ZERO
|
|
if (mat .lt. 1 .or. mat .gt. n_material) then
|
|
call error_set(FEM_ERR_MATERIAL, &
|
|
'stable time step found invalid material index', ierr)
|
|
return
|
|
end if
|
|
if (mat_density(mat) .le. ZERO) then
|
|
call error_set(FEM_ERR_MATERIAL, &
|
|
'stable time step requires positive density', ierr)
|
|
return
|
|
end if
|
|
if (mat_e(mat) .le. ZERO) then
|
|
call error_set(FEM_ERR_MATERIAL, &
|
|
'stable time step requires positive elastic modulus', ierr)
|
|
return
|
|
end if
|
|
if (mat_nu(mat) .le. -ONE .or. mat_nu(mat) .ge. HALF) then
|
|
call error_set(FEM_ERR_MATERIAL, &
|
|
'stable time step found invalid Poisson ratio', ierr)
|
|
return
|
|
end if
|
|
|
|
lambda = mat_e(mat) * mat_nu(mat) / &
|
|
((ONE + mat_nu(mat)) * (ONE - 2.0_rk * mat_nu(mat)))
|
|
mu = mat_e(mat) / (2.0_rk * (ONE + mat_nu(mat)))
|
|
wave_speed = sqrt((lambda + 2.0_rk * mu) / mat_density(mat))
|
|
ierr = FEM_SUCCESS
|
|
end subroutine estimate_material_wave_speed
|
|
|
|
subroutine estimate_element_hchar(elem, hchar, ierr)
|
|
integer, intent(in) :: elem
|
|
real(rk), intent(out) :: hchar
|
|
integer, intent(out) :: ierr
|
|
integer :: edge
|
|
integer :: nedge
|
|
integer :: num_edge_nodes
|
|
integer :: edge_nodes(MAX_FACE_NODES)
|
|
|
|
hchar = huge(ONE)
|
|
|
|
nedge = element_num_edges(elem_type(elem))
|
|
if (nedge .le. 0) then
|
|
call error_set(FEM_ERR_MESH, &
|
|
'unsupported element type for stable time step', ierr)
|
|
return
|
|
end if
|
|
|
|
do edge = 1, nedge
|
|
call element_edge_nodes(elem_type(elem), edge, num_edge_nodes, &
|
|
edge_nodes, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (num_edge_nodes .lt. 2) then
|
|
call error_set(FEM_ERR_MESH, &
|
|
'element edge has fewer than two nodes', ierr)
|
|
return
|
|
end if
|
|
call update_min_edge(elem, edge_nodes(1), edge_nodes(2), hchar)
|
|
end do
|
|
|
|
if (hchar .le. ZERO .or. hchar .gt. 0.5_rk * huge(ONE)) then
|
|
call error_set(FEM_ERR_MESH, &
|
|
'element has non-positive characteristic length', ierr)
|
|
return
|
|
end if
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine estimate_element_hchar
|
|
|
|
subroutine update_min_edge(elem, local_a, local_b, hchar)
|
|
integer, intent(in) :: elem
|
|
integer, intent(in) :: local_a
|
|
integer, intent(in) :: local_b
|
|
real(rk), intent(inout) :: hchar
|
|
real(rk) :: xa(NDIM)
|
|
real(rk) :: xb(NDIM)
|
|
real(rk) :: edge_length
|
|
integer :: node_a
|
|
integer :: node_b
|
|
|
|
node_a = elem_conn(local_a, elem)
|
|
node_b = elem_conn(local_b, elem)
|
|
call current_node_position(node_a, xa)
|
|
call current_node_position(node_b, xb)
|
|
edge_length = sqrt(sum((xb - xa) * (xb - xa)))
|
|
hchar = min(hchar, edge_length)
|
|
end subroutine update_min_edge
|
|
|
|
subroutine current_node_position(node, xyz)
|
|
integer, intent(in) :: node
|
|
real(rk), intent(out) :: xyz(NDIM)
|
|
integer :: idir
|
|
integer :: dof
|
|
|
|
xyz = coord0(:,node)
|
|
if (.not. allocated(u)) return
|
|
do idir = 1, NDIM
|
|
dof = dof_id(idir,node)
|
|
if (dof .gt. 0) xyz(idir) = xyz(idir) + u(dof)
|
|
end do
|
|
end subroutine current_node_position
|
|
|
|
end module fem_api_stable_dt
|