960 lines
29 KiB
Fortran
960 lines
29 KiB
Fortran
module fem_api
|
|
use fem_precision
|
|
use fem_error
|
|
use fem_log
|
|
use fem_control
|
|
use fem_database
|
|
use fem_inp_reader
|
|
use fem_element_topology
|
|
use fem_element_state
|
|
use fem_element_mass
|
|
use fem_element_internal
|
|
use fem_solver_implicit
|
|
use fem_coupling
|
|
use fem_boundary
|
|
use fem_output_csv
|
|
implicit none
|
|
|
|
logical :: api_initialized = .false.
|
|
|
|
contains
|
|
|
|
subroutine fem_initialize(ierr)
|
|
integer, intent(out) :: ierr
|
|
integer :: log_ierr
|
|
|
|
call error_clear(ierr)
|
|
call control_set_defaults()
|
|
call log_open('femlite.log', log_ierr)
|
|
if (log_ierr .ne. FEM_SUCCESS) then
|
|
call error_set(FEM_ERR_OUTPUT, 'failed to open femlite.log', ierr)
|
|
return
|
|
end if
|
|
|
|
api_initialized = .true.
|
|
call log_info('FemLite initialized')
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_initialize
|
|
|
|
subroutine fem_finalize(ierr)
|
|
integer, intent(out) :: ierr
|
|
|
|
call cpl_finalize_facets()
|
|
call database_finalize(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call log_info('FemLite finalized')
|
|
call log_close()
|
|
api_initialized = .false.
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_finalize
|
|
|
|
subroutine fem_get_version(major, minor, patch, ierr)
|
|
integer, intent(out) :: major
|
|
integer, intent(out) :: minor
|
|
integer, intent(out) :: patch
|
|
integer, intent(out) :: ierr
|
|
|
|
major = FEMLITE_VERSION_MAJOR
|
|
minor = FEMLITE_VERSION_MINOR
|
|
patch = FEMLITE_VERSION_PATCH
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_version
|
|
|
|
subroutine fem_read_inp(filename, ierr)
|
|
character(len=*), intent(in) :: filename
|
|
integer, intent(out) :: ierr
|
|
logical :: exists
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_read_inp called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
inquire(file=filename, exist=exists)
|
|
if (.not. exists) then
|
|
call error_set(FEM_ERR_INPUT, 'input file does not exist: '//trim(filename), ierr)
|
|
return
|
|
end if
|
|
|
|
call cpl_finalize_facets()
|
|
call output_csv_reset()
|
|
time_start = ZERO
|
|
time_end = ZERO
|
|
dt_user = ZERO
|
|
nstep_max = 0
|
|
use_user_dt = .false.
|
|
call inp_read_file(filename, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
current_time = ZERO
|
|
current_step = 0
|
|
end subroutine fem_read_inp
|
|
|
|
subroutine fem_build_model(ierr)
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_build_model called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call database_validate_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call cpl_build_facets(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call log_info('model build completed')
|
|
end subroutine fem_build_model
|
|
|
|
subroutine fem_compute_lumped_mass(ierr)
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_compute_lumped_mass called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call element_compute_lumped_mass(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call log_info('lumped mass computed')
|
|
end subroutine fem_compute_lumped_mass
|
|
|
|
subroutine fem_compute_internal_force(ierr)
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_compute_internal_force called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call element_compute_internal_force(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call log_info('internal force computed')
|
|
end subroutine fem_compute_internal_force
|
|
|
|
subroutine fem_get_mass_summary(total_mass, rotational_inertia, ierr)
|
|
real(rk), intent(out) :: total_mass
|
|
real(rk), intent(out) :: rotational_inertia
|
|
integer, intent(out) :: ierr
|
|
integer :: node
|
|
integer :: idir
|
|
integer :: dof
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_get_mass_summary called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
total_mass = ZERO
|
|
rotational_inertia = ZERO
|
|
if (.not. allocated(mass_diag)) then
|
|
call error_set(FEM_ERR_INTERNAL, 'mass vector is not allocated', ierr)
|
|
return
|
|
end if
|
|
|
|
do node = 1, nnode
|
|
dof = dof_id(1,node)
|
|
if (dof .gt. 0) total_mass = total_mass + mass_diag(dof)
|
|
|
|
do idir = 4, NDOF_NODE
|
|
dof = dof_id(idir,node)
|
|
if (dof .gt. 0) rotational_inertia = rotational_inertia + mass_diag(dof)
|
|
end do
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_mass_summary
|
|
|
|
subroutine fem_clear_sph_forces(ierr)
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_clear_sph_forces called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (.not. allocated(fsph)) then
|
|
call error_set(FEM_ERR_INTERNAL, 'SPH force vector is not allocated', ierr)
|
|
return
|
|
end if
|
|
|
|
fsph = ZERO
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_clear_sph_forces
|
|
|
|
subroutine fem_apply_sph_nodal_force(node_id, force, ierr)
|
|
integer, intent(in) :: node_id
|
|
real(rk), intent(in) :: force(NDIM)
|
|
integer, intent(out) :: ierr
|
|
integer :: node
|
|
integer :: idir
|
|
integer :: dof
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_apply_sph_nodal_force called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (.not. allocated(fsph)) then
|
|
call error_set(FEM_ERR_INTERNAL, 'SPH force vector is not allocated', ierr)
|
|
return
|
|
end if
|
|
|
|
node = database_find_node(node_id)
|
|
if (node .eq. 0) then
|
|
call error_set(FEM_ERR_COUPLING, 'SPH nodal force references unknown node', ierr)
|
|
return
|
|
end if
|
|
|
|
do idir = 1, NDIM
|
|
dof = dof_id(idir,node)
|
|
if (dof .gt. 0) fsph(dof) = fsph(dof) + force(idir)
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_apply_sph_nodal_force
|
|
|
|
subroutine fem_apply_sph_nodal_forces(num_force_nodes, node_ids, force, ierr)
|
|
integer, intent(in) :: num_force_nodes
|
|
integer, intent(in) :: node_ids(num_force_nodes)
|
|
real(rk), intent(in) :: force(NDIM,num_force_nodes)
|
|
integer, intent(out) :: ierr
|
|
integer :: item
|
|
integer :: node
|
|
integer :: idir
|
|
integer :: dof
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_apply_sph_nodal_forces called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (.not. allocated(fsph)) then
|
|
call error_set(FEM_ERR_INTERNAL, 'SPH force vector is not allocated', ierr)
|
|
return
|
|
end if
|
|
if (num_force_nodes .lt. 0) then
|
|
call error_set(FEM_ERR_COUPLING, 'number of SPH force nodes is negative', ierr)
|
|
return
|
|
end if
|
|
|
|
do item = 1, num_force_nodes
|
|
node = database_find_node(node_ids(item))
|
|
if (node .eq. 0) then
|
|
call error_set(FEM_ERR_COUPLING, 'SPH nodal force references unknown node', ierr)
|
|
return
|
|
end if
|
|
end do
|
|
|
|
do item = 1, num_force_nodes
|
|
node = database_find_node(node_ids(item))
|
|
do idir = 1, NDIM
|
|
dof = dof_id(idir,node)
|
|
if (dof .gt. 0) fsph(dof) = fsph(dof) + force(idir,item)
|
|
end do
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_apply_sph_nodal_forces
|
|
|
|
subroutine fem_get_sph_force_summary(total_force, ierr)
|
|
real(rk), intent(out) :: total_force(NDIM)
|
|
integer, intent(out) :: ierr
|
|
integer :: node
|
|
integer :: idir
|
|
integer :: dof
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_get_sph_force_summary called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (.not. allocated(fsph)) then
|
|
call error_set(FEM_ERR_INTERNAL, 'SPH force vector is not allocated', ierr)
|
|
return
|
|
end if
|
|
|
|
total_force = ZERO
|
|
do node = 1, nnode
|
|
do idir = 1, NDIM
|
|
dof = dof_id(idir,node)
|
|
if (dof .gt. 0) total_force(idir) = total_force(idir) + fsph(dof)
|
|
end do
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_sph_force_summary
|
|
|
|
subroutine fem_get_boundary_facet_count(num_facets, max_face_nodes, ierr)
|
|
integer, intent(out) :: num_facets
|
|
integer, intent(out) :: max_face_nodes
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_get_boundary_facet_count called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call cpl_get_facet_count(num_facets, max_face_nodes, ierr)
|
|
end subroutine fem_get_boundary_facet_count
|
|
|
|
subroutine fem_get_boundary_facets(nfacet_in, max_face_nodes_in, &
|
|
facet_id, elem_id, face_id, facet_nnode, &
|
|
facet_conn, x, vnod, normal, area, ierr)
|
|
integer, intent(in) :: nfacet_in
|
|
integer, intent(in) :: max_face_nodes_in
|
|
integer, intent(out) :: facet_id(nfacet_in)
|
|
integer, intent(out) :: elem_id(nfacet_in)
|
|
integer, intent(out) :: face_id(nfacet_in)
|
|
integer, intent(out) :: facet_nnode(nfacet_in)
|
|
integer, intent(out) :: facet_conn(max_face_nodes_in,nfacet_in)
|
|
real(rk), intent(out) :: x(NDIM,max_face_nodes_in,nfacet_in)
|
|
real(rk), intent(out) :: vnod(NDIM,max_face_nodes_in,nfacet_in)
|
|
real(rk), intent(out) :: normal(NDIM,nfacet_in)
|
|
real(rk), intent(out) :: area(nfacet_in)
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_get_boundary_facets called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call cpl_get_facets(nfacet_in, max_face_nodes_in, &
|
|
facet_id, elem_id, face_id, facet_nnode, &
|
|
facet_conn, x, vnod, normal, area, ierr)
|
|
end subroutine fem_get_boundary_facets
|
|
|
|
subroutine fem_apply_sph_facet_pressure(nfacet_in, facet_id, pressure, ierr)
|
|
integer, intent(in) :: nfacet_in
|
|
integer, intent(in) :: facet_id(nfacet_in)
|
|
real(rk), intent(in) :: pressure(nfacet_in)
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_apply_sph_facet_pressure called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call cpl_apply_facet_pressure(nfacet_in, facet_id, pressure, ierr)
|
|
end subroutine fem_apply_sph_facet_pressure
|
|
|
|
subroutine fem_apply_sph_facet_tractions(nfacet_in, facet_id, pressure, shear, ierr)
|
|
integer, intent(in) :: nfacet_in
|
|
integer, intent(in) :: facet_id(nfacet_in)
|
|
real(rk), intent(in) :: pressure(nfacet_in)
|
|
real(rk), intent(in) :: shear(NDIM,nfacet_in)
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_apply_sph_facet_tractions called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call cpl_apply_facet_tractions(nfacet_in, facet_id, pressure, shear, ierr)
|
|
end subroutine fem_apply_sph_facet_tractions
|
|
|
|
subroutine fem_get_node_kinematics(node_id, displacement, velocity, acceleration, ierr)
|
|
integer, intent(in) :: node_id
|
|
real(rk), intent(out) :: displacement(NDIM)
|
|
real(rk), intent(out) :: velocity(NDIM)
|
|
real(rk), intent(out) :: acceleration(NDIM)
|
|
integer, intent(out) :: ierr
|
|
integer :: node
|
|
integer :: idir
|
|
integer :: dof
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_get_node_kinematics called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
node = database_find_node(node_id)
|
|
if (node .eq. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'node kinematics query references unknown node', ierr)
|
|
return
|
|
end if
|
|
|
|
displacement = ZERO
|
|
velocity = ZERO
|
|
acceleration = ZERO
|
|
do idir = 1, NDIM
|
|
dof = dof_id(idir,node)
|
|
if (dof .gt. 0) then
|
|
displacement(idir) = u(dof)
|
|
velocity(idir) = v(dof)
|
|
acceleration(idir) = a(dof)
|
|
end if
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_node_kinematics
|
|
|
|
subroutine fem_set_node_displacement(node_id, displacement, ierr)
|
|
integer, intent(in) :: node_id
|
|
real(rk), intent(in) :: displacement(NDIM)
|
|
integer, intent(out) :: ierr
|
|
integer :: node
|
|
integer :: idir
|
|
integer :: dof
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_set_node_displacement called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
node = database_find_node(node_id)
|
|
if (node .eq. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'node displacement setter references unknown node', ierr)
|
|
return
|
|
end if
|
|
|
|
do idir = 1, NDIM
|
|
dof = dof_id(idir,node)
|
|
if (dof .gt. 0) u(dof) = displacement(idir)
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_set_node_displacement
|
|
|
|
subroutine fem_get_node_internal_force(node_id, force, ierr)
|
|
integer, intent(in) :: node_id
|
|
real(rk), intent(out) :: force(NDIM)
|
|
integer, intent(out) :: ierr
|
|
integer :: node
|
|
integer :: idir
|
|
integer :: dof
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_get_node_internal_force called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (.not. allocated(fint)) then
|
|
call error_set(FEM_ERR_INTERNAL, 'internal force vector is not allocated', ierr)
|
|
return
|
|
end if
|
|
|
|
node = database_find_node(node_id)
|
|
if (node .eq. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'internal force query references unknown node', ierr)
|
|
return
|
|
end if
|
|
|
|
force = ZERO
|
|
do idir = 1, NDIM
|
|
dof = dof_id(idir,node)
|
|
if (dof .gt. 0) force(idir) = fint(dof)
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_node_internal_force
|
|
|
|
subroutine fem_get_element_average_state(nelem_in, elem_id, stress_out, &
|
|
strain_out, plastic_strain, eqps, &
|
|
damage, ierr)
|
|
integer, intent(in) :: nelem_in
|
|
integer, intent(in) :: elem_id(nelem_in)
|
|
real(rk), intent(out) :: stress_out(NSTRESS,nelem_in)
|
|
real(rk), intent(out) :: strain_out(NSTRESS,nelem_in)
|
|
real(rk), intent(out) :: plastic_strain(NSTRESS,nelem_in)
|
|
real(rk), intent(out) :: eqps(nelem_in)
|
|
real(rk), intent(out) :: damage(nelem_in)
|
|
integer, intent(out) :: ierr
|
|
integer :: item
|
|
integer :: elem
|
|
integer :: gp
|
|
integer :: gp_start
|
|
integer :: gp_count
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_get_element_average_state called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (.not. element_state_is_available()) then
|
|
call error_set(FEM_ERR_INTERNAL, 'element state is not available', ierr)
|
|
return
|
|
end if
|
|
|
|
stress_out = ZERO
|
|
strain_out = ZERO
|
|
plastic_strain = ZERO
|
|
eqps = ZERO
|
|
damage = ZERO
|
|
|
|
do item = 1, nelem_in
|
|
elem = database_find_elem(elem_id(item))
|
|
if (elem .eq. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'element average state references unknown element', ierr)
|
|
return
|
|
end if
|
|
gp_start = elem_gp_start(elem)
|
|
gp_count = elem_ngp(elem)
|
|
if (gp_start .le. 0 .or. gp_count .le. 0) then
|
|
call error_set(FEM_ERR_OUTPUT, 'element state is not available for requested element', ierr)
|
|
return
|
|
end if
|
|
|
|
do gp = gp_start, gp_start + gp_count - 1
|
|
stress_out(:,item) = stress_out(:,item) + stress(:,gp)
|
|
strain_out(:,item) = strain_out(:,item) + strain(:,gp)
|
|
plastic_strain(:,item) = plastic_strain(:,item) + statev(5:10,gp)
|
|
eqps(item) = eqps(item) + statev(1,gp)
|
|
damage(item) = damage(item) + statev(2,gp)
|
|
end do
|
|
|
|
stress_out(:,item) = stress_out(:,item) / real(gp_count, rk)
|
|
strain_out(:,item) = strain_out(:,item) / real(gp_count, rk)
|
|
plastic_strain(:,item) = plastic_strain(:,item) / real(gp_count, rk)
|
|
eqps(item) = eqps(item) / real(gp_count, rk)
|
|
damage(item) = damage(item) / real(gp_count, rk)
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_element_average_state
|
|
|
|
subroutine fem_get_element_status(nelem_in, elem_id, status, ierr)
|
|
integer, intent(in) :: nelem_in
|
|
integer, intent(in) :: elem_id(nelem_in)
|
|
integer, intent(out) :: status(nelem_in)
|
|
integer, intent(out) :: ierr
|
|
integer :: item
|
|
integer :: elem
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_get_element_status called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (.not. allocated(elem_status)) then
|
|
call error_set(FEM_ERR_INTERNAL, 'element status array is not allocated', ierr)
|
|
return
|
|
end if
|
|
|
|
status = 0
|
|
do item = 1, nelem_in
|
|
elem = database_find_elem(elem_id(item))
|
|
if (elem .eq. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'element status query references unknown element', ierr)
|
|
return
|
|
end if
|
|
status(item) = elem_status(elem)
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_element_status
|
|
|
|
subroutine fem_set_output_directory(path, ierr)
|
|
character(len=*), intent(in) :: path
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_set_output_directory called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call output_csv_set_directory(path, ierr)
|
|
end subroutine fem_set_output_directory
|
|
|
|
subroutine fem_set_output_interval(interval, ierr)
|
|
integer, intent(in) :: interval
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_set_output_interval called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call output_csv_set_interval(interval, ierr)
|
|
end subroutine fem_set_output_interval
|
|
|
|
subroutine fem_write_output(step, time, ierr)
|
|
integer, intent(in) :: step
|
|
real(rk), intent(in) :: time
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_write_output called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call output_csv_write(step, time, ierr)
|
|
end subroutine fem_write_output
|
|
|
|
subroutine fem_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 (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_estimate_stable_dt called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
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 fem_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
|
|
|
|
subroutine fem_advance_explicit(dt, ierr)
|
|
real(rk), intent(in) :: dt
|
|
integer, intent(out) :: ierr
|
|
real(rk) :: rhs
|
|
integer :: dof
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_advance_explicit called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (dt .le. ZERO) then
|
|
call error_set(FEM_ERR_SOLVER, 'explicit time step must be positive', ierr)
|
|
return
|
|
end if
|
|
if (.not. allocated(mass_diag)) then
|
|
call error_set(FEM_ERR_INTERNAL, 'mass vector is not allocated', ierr)
|
|
return
|
|
end if
|
|
|
|
do dof = 1, ndof
|
|
if (mass_diag(dof) .le. ZERO) then
|
|
call error_set(FEM_ERR_SOLVER, 'non-positive lumped mass in explicit step', ierr)
|
|
return
|
|
end if
|
|
end do
|
|
|
|
call boundary_apply_dirichlet(current_time, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call element_compute_internal_force(ierr, dt)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call boundary_apply_prescribed_loads(current_time, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call boundary_apply_robin_forces(current_time, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call boundary_apply_mpc_forces(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
do dof = 1, ndof
|
|
rhs = fext(dof) + fsph(dof) + fcontact(dof) - fint(dof)
|
|
a(dof) = rhs / mass_diag(dof)
|
|
|
|
if (current_step .eq. 0) then
|
|
vhalf(dof) = v(dof) + HALF * dt * a(dof)
|
|
else
|
|
vhalf(dof) = vhalf(dof) + dt * a(dof)
|
|
end if
|
|
|
|
u(dof) = u(dof) + dt * vhalf(dof)
|
|
v(dof) = vhalf(dof) + HALF * dt * a(dof)
|
|
end do
|
|
|
|
call boundary_apply_dirichlet(current_time + dt, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
current_step = current_step + 1
|
|
current_time = current_time + dt
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_advance_explicit
|
|
|
|
subroutine fem_run_explicit(ierr)
|
|
integer, intent(out) :: ierr
|
|
real(rk) :: dt
|
|
real(rk) :: dt_step
|
|
real(rk) :: remaining
|
|
real(rk) :: time_tol
|
|
integer :: run_steps
|
|
integer :: step_limit
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_run_explicit called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
if (time_end .le. current_time) then
|
|
call error_set(FEM_ERR_SOLVER, 'explicit run requires a positive end time', ierr)
|
|
return
|
|
end if
|
|
|
|
call fem_compute_lumped_mass(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
if (use_user_dt) then
|
|
dt = dt_user
|
|
else
|
|
call fem_estimate_stable_dt(dt, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
end if
|
|
if (dt .le. ZERO) then
|
|
call error_set(FEM_ERR_SOLVER, 'explicit run requires a positive time step', ierr)
|
|
return
|
|
end if
|
|
|
|
call boundary_apply_dirichlet(current_time, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
if (output_interval .gt. 0) then
|
|
call fem_write_output(current_step, current_time, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
end if
|
|
|
|
if (nstep_max .gt. 0) then
|
|
step_limit = nstep_max
|
|
else
|
|
step_limit = huge(1)
|
|
end if
|
|
run_steps = 0
|
|
time_tol = max(1.0e-12_rk * max(ONE, abs(time_end)), 1.0e-30_rk)
|
|
|
|
do
|
|
remaining = time_end - current_time
|
|
if (remaining .le. time_tol) exit
|
|
if (run_steps .ge. step_limit) exit
|
|
|
|
dt_step = min(dt, remaining)
|
|
call fem_advance_explicit(dt_step, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
run_steps = run_steps + 1
|
|
|
|
if (output_interval .gt. 0) then
|
|
if (mod(current_step, output_interval) .eq. 0 .or. &
|
|
time_end - current_time .le. time_tol) then
|
|
call fem_write_output(current_step, current_time, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
end if
|
|
end if
|
|
end do
|
|
|
|
if (time_end - current_time .gt. time_tol) then
|
|
call error_set(FEM_ERR_SOLVER, 'explicit run stopped before end time', ierr)
|
|
return
|
|
end if
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_run_explicit
|
|
|
|
subroutine fem_solve_implicit_linear(max_iter, tol, iter, res_norm, ierr)
|
|
integer, intent(in) :: max_iter
|
|
real(rk), intent(in) :: tol
|
|
integer, intent(out) :: iter
|
|
real(rk), intent(out) :: res_norm
|
|
integer, intent(out) :: ierr
|
|
|
|
if (.not. api_initialized) then
|
|
call error_set(FEM_ERR_INTERNAL, 'fem_solve_implicit_linear called before fem_initialize', ierr)
|
|
return
|
|
end if
|
|
|
|
call implicit_solve_linear_static(current_time, max_iter, tol, iter, res_norm, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
current_step = current_step + 1
|
|
call log_info('implicit linear solve completed')
|
|
end subroutine fem_solve_implicit_linear
|
|
|
|
subroutine fem_get_current_time(time, step, ierr)
|
|
real(rk), intent(out) :: time
|
|
integer, intent(out) :: step
|
|
integer, intent(out) :: ierr
|
|
|
|
time = current_time
|
|
step = current_step
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_current_time
|
|
|
|
subroutine fem_get_time_control(dt, end_time, max_steps, user_dt, ierr)
|
|
real(rk), intent(out) :: dt
|
|
real(rk), intent(out) :: end_time
|
|
integer, intent(out) :: max_steps
|
|
logical, intent(out) :: user_dt
|
|
integer, intent(out) :: ierr
|
|
|
|
dt = dt_user
|
|
end_time = time_end
|
|
max_steps = nstep_max
|
|
user_dt = use_user_dt
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_time_control
|
|
|
|
subroutine fem_get_model_size(num_nodes, num_elems, num_dof, ierr)
|
|
integer, intent(out) :: num_nodes
|
|
integer, intent(out) :: num_elems
|
|
integer, intent(out) :: num_dof
|
|
integer, intent(out) :: ierr
|
|
|
|
num_nodes = nnode
|
|
num_elems = nelem
|
|
num_dof = ndof
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_model_size
|
|
|
|
subroutine fem_get_model_counts(num_nodes, num_elems, num_dof, num_nsets, &
|
|
num_elsets, num_materials, num_sections, &
|
|
num_nset_items, num_elset_items, ierr)
|
|
integer, intent(out) :: num_nodes
|
|
integer, intent(out) :: num_elems
|
|
integer, intent(out) :: num_dof
|
|
integer, intent(out) :: num_nsets
|
|
integer, intent(out) :: num_elsets
|
|
integer, intent(out) :: num_materials
|
|
integer, intent(out) :: num_sections
|
|
integer, intent(out) :: num_nset_items
|
|
integer, intent(out) :: num_elset_items
|
|
integer, intent(out) :: ierr
|
|
|
|
num_nodes = nnode
|
|
num_elems = nelem
|
|
num_dof = ndof
|
|
num_nsets = n_nset
|
|
num_elsets = n_elset
|
|
num_materials = n_material
|
|
num_sections = n_section
|
|
num_nset_items = 0
|
|
num_elset_items = 0
|
|
if (allocated(nset_count)) num_nset_items = sum(nset_count)
|
|
if (allocated(elset_count)) num_elset_items = sum(elset_count)
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_model_counts
|
|
|
|
subroutine fem_get_load_counts(num_bc, num_cload, num_dload, ierr)
|
|
integer, intent(out) :: num_bc
|
|
integer, intent(out) :: num_cload
|
|
integer, intent(out) :: num_dload
|
|
integer, intent(out) :: ierr
|
|
|
|
num_bc = nbc
|
|
num_cload = ncload
|
|
num_dload = ndload
|
|
ierr = FEM_SUCCESS
|
|
end subroutine fem_get_load_counts
|
|
|
|
end module fem_api
|