975 lines
38 KiB
Fortran
975 lines
38 KiB
Fortran
program test_restart
|
|
use fem_precision
|
|
use fem_error
|
|
use fem_api
|
|
use fem_api_diagnostics, only: fem_get_nl_lifecycle_snapshot, &
|
|
fem_get_nl_lifecycle_arc, fem_get_nl_lifecycle_audit
|
|
use fem_control, only: NFAIL_NONE
|
|
use fem_nonlinear_lifecycle, only: NLC_EVENT_NONE, NLC_EVENT_ACCEPT, &
|
|
NLC_EVENT_COMMIT, NLC_AUDIT_NONE, NLC_AUDIT_BEGIN_TRIAL, &
|
|
NLC_AUDIT_COMMIT_OK, &
|
|
nl_lifecycle_reset, &
|
|
nl_lifecycle_begin_increment, nl_lifecycle_record_event, &
|
|
nl_lifecycle_record_audit, nl_lifecycle_record_arc_state, &
|
|
nl_lifecycle_mark_path_appended
|
|
use fem_shell_rotation, only: shell_rotation_ensure, &
|
|
shell_rotation_set_committed, shell_rotation_get_committed, &
|
|
shell_rotation_rotate_vector
|
|
use fem_contact_multiplier, only: contact_multiplier_store_trial, &
|
|
contact_multiplier_commit, contact_multiplier_stats, &
|
|
contact_multiplier_audit, contact_multiplier_state_counts, &
|
|
contact_multiplier_resid_stats
|
|
use fem_contact_history, only: contact_history_state_stats, &
|
|
contact_history_stable_counts
|
|
implicit none
|
|
|
|
real(rk), parameter :: DT_TEST = 1.0e-8_rk
|
|
real(rk), parameter :: DT_CONTACT = 1.0e-5_rk
|
|
integer, parameter :: CONTACT_STEPS = 20
|
|
character(len=*), parameter :: RESTART_FILE = &
|
|
'build-wsl-debug/restart_check.frs'
|
|
character(len=*), parameter :: CONTACT_RESTART_FILE = &
|
|
'build-wsl-debug/contact_history_restart.frs'
|
|
character(len=*), parameter :: MULT_RESTART_FILE = &
|
|
'build-wsl-debug/contact_multiplier_restart.frs'
|
|
character(len=*), parameter :: ROT_RESTART_FILE = &
|
|
'build-wsl-debug/shell_rotation_restart.frs'
|
|
character(len=*), parameter :: LIFECYCLE_RESTART_FILE = &
|
|
'build-wsl-debug/lifecycle_restart.frs'
|
|
character(len=*), parameter :: LEGACY_LIFECYCLE_RESTART_FILE = &
|
|
'build-wsl-debug/lifecycle_restart_legacy.frs'
|
|
character(len=*), parameter :: BAD_LIFECYCLE_RESTART_FILE = &
|
|
'build-wsl-debug/lifecycle_restart_bad.frs'
|
|
character(len=*), parameter :: EACH_ACCEPT_RESTART_FILE = &
|
|
'build-wsl-debug/restart_after_each_accept.frs'
|
|
|
|
type contact_restart_snapshot
|
|
integer :: slots = 0
|
|
integer :: hist_slots = 0
|
|
integer :: stick = 0
|
|
integer :: slip_state = 0
|
|
integer :: stable_slots = 0
|
|
integer :: state_open = 0
|
|
integer :: state_stick = 0
|
|
integer :: state_slip = 0
|
|
integer :: state_restick = 0
|
|
integer :: state_separating = 0
|
|
integer :: state_failed = 0
|
|
integer :: active_summary = 0
|
|
integer :: active_pair = 0
|
|
integer :: activated_pair = 0
|
|
integer :: maintained_pair = 0
|
|
integer :: released_pair = 0
|
|
integer :: pair_open = 0
|
|
integer :: pair_stick = 0
|
|
integer :: pair_slip = 0
|
|
integer :: pair_restick = 0
|
|
integer :: pair_separating = 0
|
|
integer :: pair_failed = 0
|
|
integer :: pair_flip = 0
|
|
real(rk) :: slip = ZERO
|
|
real(rk) :: work = ZERO
|
|
real(rk) :: tangent = ZERO
|
|
real(rk) :: work_step = ZERO
|
|
real(rk) :: work_total = ZERO
|
|
real(rk) :: max_pen = ZERO
|
|
real(rk) :: force_norm = ZERO
|
|
real(rk) :: max_gap = ZERO
|
|
real(rk) :: max_aug = ZERO
|
|
real(rk) :: fric_step = ZERO
|
|
real(rk) :: fric_total = ZERO
|
|
real(rk) :: max_slip = ZERO
|
|
real(rk) :: pair_gap_max = ZERO
|
|
real(rk) :: pair_gap_mean = ZERO
|
|
real(rk) :: pair_gap_l2 = ZERO
|
|
real(rk) :: pair_slip_inc = ZERO
|
|
real(rk) :: pair_slip_resid = ZERO
|
|
real(rk) :: pair_fric_resid = ZERO
|
|
end type contact_restart_snapshot
|
|
|
|
integer :: ierr
|
|
integer :: ref_step
|
|
integer :: rst_step
|
|
real(rk) :: ref_time
|
|
real(rk) :: rst_time
|
|
real(rk) :: ref_u(NDIM)
|
|
real(rk) :: ref_v(NDIM)
|
|
real(rk) :: ref_a(NDIM)
|
|
real(rk) :: rst_u(NDIM)
|
|
real(rk) :: rst_v(NDIM)
|
|
real(rk) :: rst_a(NDIM)
|
|
|
|
call fem_initialize(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(1)
|
|
|
|
call run_continuous(ref_step, ref_time, ref_u, ref_v, ref_a, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(2)
|
|
|
|
call run_restarted(rst_step, rst_time, rst_u, rst_v, rst_a, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(3)
|
|
|
|
if (ref_step .ne. 3) call fail(4)
|
|
if (rst_step .ne. ref_step) call fail(5)
|
|
call check_close(rst_time, ref_time, 6)
|
|
call check_vector(rst_u, ref_u, 7)
|
|
call check_vector(rst_v, ref_v, 8)
|
|
call check_vector(rst_a, ref_a, 9)
|
|
|
|
call check_contact_history_restart(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(11)
|
|
call check_mult_restart(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(22)
|
|
call check_shell_rotation_restart(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(40)
|
|
call check_lifecycle_restart(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(50)
|
|
call check_restart_each_accept(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(51)
|
|
|
|
call fem_finalize(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(12)
|
|
|
|
contains
|
|
|
|
subroutine run_continuous(step, time, disp, vel, acc, ierr)
|
|
integer, intent(out) :: step
|
|
real(rk), intent(out) :: time
|
|
real(rk), intent(out) :: disp(NDIM)
|
|
real(rk), intent(out) :: vel(NDIM)
|
|
real(rk), intent(out) :: acc(NDIM)
|
|
integer, intent(out) :: ierr
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call fem_get_current_time(time, step, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_node_kinematics(2, disp, vel, acc, ierr)
|
|
end subroutine run_continuous
|
|
|
|
subroutine run_restarted(step, time, disp, vel, acc, ierr)
|
|
integer, intent(out) :: step
|
|
real(rk), intent(out) :: time
|
|
real(rk), intent(out) :: disp(NDIM)
|
|
real(rk), intent(out) :: vel(NDIM)
|
|
real(rk), intent(out) :: acc(NDIM)
|
|
integer, intent(out) :: ierr
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_write_restart(RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_read_restart(RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call fem_get_current_time(time, step, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_node_kinematics(2, disp, vel, acc, ierr)
|
|
end subroutine run_restarted
|
|
|
|
subroutine prepare_model(ierr)
|
|
integer, intent(out) :: ierr
|
|
|
|
call fem_read_inp('examples/c3d4_one_element.inp', ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_build_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_compute_lumped_mass(ierr)
|
|
end subroutine prepare_model
|
|
|
|
subroutine loaded_step(ierr)
|
|
integer, intent(out) :: ierr
|
|
real(rk) :: force(NDIM)
|
|
|
|
force = ZERO
|
|
force(1) = 5.0_rk
|
|
force(2) = 1.0_rk
|
|
force(3) = -2.0_rk
|
|
|
|
call fem_clear_sph_forces(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_apply_sph_nodal_force(2, force, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_advance_explicit(DT_TEST, ierr)
|
|
end subroutine loaded_step
|
|
|
|
subroutine check_contact_history_restart(ierr)
|
|
integer, intent(out) :: ierr
|
|
type(contact_restart_snapshot) :: before
|
|
type(contact_restart_snapshot) :: after
|
|
|
|
call prepare_contact_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call run_contact_steps(CONTACT_STEPS, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call capture_contact_snap(before, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call validate_contact_before(before)
|
|
|
|
call fem_write_restart(CONTACT_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call prepare_contact_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call validate_empty_contact(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call fem_read_restart(CONTACT_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call capture_contact_snap(after, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call compare_contact_snaps(after, before)
|
|
end subroutine check_contact_history_restart
|
|
|
|
subroutine capture_contact_snap(snap, ierr)
|
|
type(contact_restart_snapshot), intent(out) :: snap
|
|
integer, intent(out) :: ierr
|
|
|
|
call fem_get_contact_summary(snap%active_summary, snap%work_step, &
|
|
snap%work_total, snap%max_pen, snap%force_norm, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_contact_diagnostics(snap%active_pair, snap%activated_pair, &
|
|
snap%maintained_pair, snap%released_pair, snap%max_gap, snap%max_aug, &
|
|
ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_contact_friction(snap%fric_step, snap%fric_total, &
|
|
snap%max_slip, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_contact_state_summary(snap%pair_open, snap%pair_stick, &
|
|
snap%pair_slip, snap%pair_restick, snap%pair_separating, &
|
|
snap%pair_failed, snap%pair_gap_max, snap%pair_gap_mean, &
|
|
snap%pair_gap_l2, snap%pair_slip_inc, snap%pair_slip_resid, &
|
|
snap%pair_fric_resid, snap%pair_flip, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_contact_hist_stats(snap%slots, snap%slip, snap%work, &
|
|
snap%tangent, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call contact_history_state_stats(snap%hist_slots, snap%stick, &
|
|
snap%slip_state)
|
|
call contact_history_stable_counts(snap%stable_slots, snap%state_open, &
|
|
snap%state_stick, snap%state_slip, snap%state_restick, &
|
|
snap%state_separating, snap%state_failed)
|
|
end subroutine capture_contact_snap
|
|
|
|
subroutine validate_contact_before(snap)
|
|
type(contact_restart_snapshot), intent(in) :: snap
|
|
|
|
if (snap%slots .le. 0) call fail(13)
|
|
if (snap%slip .le. ZERO) call fail(14)
|
|
if (snap%work .le. ZERO) call fail(15)
|
|
if (snap%tangent .le. ZERO) call fail(16)
|
|
if (snap%active_summary .le. 0) call fail(395)
|
|
if (snap%active_pair .le. 0) call fail(396)
|
|
if (snap%force_norm .le. ZERO) call fail(397)
|
|
if (snap%max_gap .le. ZERO) call fail(398)
|
|
if (snap%max_slip .le. ZERO) call fail(399)
|
|
if (snap%pair_stick + snap%pair_slip + snap%pair_restick .le. 0) &
|
|
call fail(414)
|
|
if (snap%pair_failed .ne. 0) call fail(415)
|
|
if (snap%pair_gap_max .le. ZERO) call fail(416)
|
|
if (snap%pair_gap_l2 .lt. snap%pair_gap_max) call fail(417)
|
|
if (snap%pair_slip_inc .le. ZERO) call fail(418)
|
|
if (snap%pair_slip_resid .lt. ZERO) call fail(419)
|
|
if (snap%pair_fric_resid .le. ZERO) call fail(420)
|
|
if (snap%pair_flip .le. 0) call fail(421)
|
|
call validate_contact_counts(snap)
|
|
end subroutine validate_contact_before
|
|
|
|
subroutine validate_contact_counts(snap)
|
|
type(contact_restart_snapshot), intent(in) :: snap
|
|
|
|
if (snap%hist_slots .ne. snap%slots) call fail(360)
|
|
if (snap%stick + snap%slip_state .ne. snap%hist_slots) call fail(361)
|
|
if (snap%stable_slots .ne. snap%hist_slots) call fail(367)
|
|
if (snap%state_open .ne. 0) call fail(368)
|
|
if (snap%state_stick .ne. snap%stick) call fail(369)
|
|
if (snap%state_slip .ne. snap%slip_state) call fail(370)
|
|
if (snap%state_restick + snap%state_separating + &
|
|
snap%state_failed .ne. 0) call fail(371)
|
|
end subroutine validate_contact_counts
|
|
|
|
subroutine validate_empty_contact(ierr)
|
|
integer, intent(out) :: ierr
|
|
type(contact_restart_snapshot) :: snap
|
|
|
|
call contact_history_state_stats(snap%hist_slots, snap%stick, &
|
|
snap%slip_state)
|
|
call contact_history_stable_counts(snap%stable_slots, snap%state_open, &
|
|
snap%state_stick, snap%state_slip, snap%state_restick, &
|
|
snap%state_separating, snap%state_failed)
|
|
if (snap%hist_slots .ne. 0) call fail(362)
|
|
if (snap%stable_slots .ne. 0) call fail(372)
|
|
call fem_get_contact_hist_stats(snap%slots, snap%slip, snap%work, &
|
|
snap%tangent, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (snap%slots .ne. 0) call fail(17)
|
|
end subroutine validate_empty_contact
|
|
|
|
subroutine compare_contact_snaps(after, before)
|
|
type(contact_restart_snapshot), intent(in) :: after
|
|
type(contact_restart_snapshot), intent(in) :: before
|
|
|
|
if (after%slots .ne. before%slots) call fail(18)
|
|
call check_close(after%slip, before%slip, 19)
|
|
call check_close(after%work, before%work, 20)
|
|
call check_close(after%tangent, before%tangent, 21)
|
|
call compare_contact_counts(after, before)
|
|
call compare_contact_summary(after, before)
|
|
call compare_contact_pair(after, before)
|
|
end subroutine compare_contact_snaps
|
|
|
|
subroutine compare_contact_counts(after, before)
|
|
type(contact_restart_snapshot), intent(in) :: after
|
|
type(contact_restart_snapshot), intent(in) :: before
|
|
|
|
if (after%hist_slots .ne. before%hist_slots) call fail(363)
|
|
if (after%stick .ne. before%stick) call fail(364)
|
|
if (after%slip_state .ne. before%slip_state) call fail(365)
|
|
if (after%stick + after%slip_state .ne. after%hist_slots) call fail(366)
|
|
if (after%stable_slots .ne. before%stable_slots) call fail(373)
|
|
if (after%state_open .ne. before%state_open) call fail(374)
|
|
if (after%state_stick .ne. before%state_stick) call fail(375)
|
|
if (after%state_slip .ne. before%state_slip) call fail(376)
|
|
if (after%state_restick .ne. before%state_restick) call fail(377)
|
|
if (after%state_separating .ne. before%state_separating) call fail(378)
|
|
if (after%state_failed .ne. before%state_failed) call fail(379)
|
|
end subroutine compare_contact_counts
|
|
|
|
subroutine compare_contact_summary(after, before)
|
|
type(contact_restart_snapshot), intent(in) :: after
|
|
type(contact_restart_snapshot), intent(in) :: before
|
|
|
|
if (after%active_summary .ne. before%active_summary) call fail(400)
|
|
if (after%active_pair .ne. before%active_pair) call fail(401)
|
|
if (after%activated_pair .ne. before%activated_pair) call fail(402)
|
|
if (after%maintained_pair .ne. before%maintained_pair) call fail(403)
|
|
if (after%released_pair .ne. before%released_pair) call fail(404)
|
|
call check_close(after%work_step, before%work_step, 405)
|
|
call check_close(after%work_total, before%work_total, 406)
|
|
call check_close(after%max_pen, before%max_pen, 407)
|
|
call check_close(after%force_norm, before%force_norm, 408)
|
|
call check_close(after%max_gap, before%max_gap, 409)
|
|
call check_close(after%max_aug, before%max_aug, 410)
|
|
call check_close(after%fric_step, before%fric_step, 411)
|
|
call check_close(after%fric_total, before%fric_total, 412)
|
|
call check_close(after%max_slip, before%max_slip, 413)
|
|
end subroutine compare_contact_summary
|
|
|
|
subroutine compare_contact_pair(after, before)
|
|
type(contact_restart_snapshot), intent(in) :: after
|
|
type(contact_restart_snapshot), intent(in) :: before
|
|
|
|
if (after%pair_open .ne. before%pair_open) call fail(422)
|
|
if (after%pair_stick .ne. before%pair_stick) call fail(423)
|
|
if (after%pair_slip .ne. before%pair_slip) call fail(424)
|
|
if (after%pair_restick .ne. before%pair_restick) call fail(425)
|
|
if (after%pair_separating .ne. before%pair_separating) call fail(426)
|
|
if (after%pair_failed .ne. before%pair_failed) call fail(427)
|
|
call check_close(after%pair_gap_max, before%pair_gap_max, 428)
|
|
call check_close(after%pair_gap_mean, before%pair_gap_mean, 429)
|
|
call check_close(after%pair_gap_l2, before%pair_gap_l2, 430)
|
|
call check_close(after%pair_slip_inc, before%pair_slip_inc, 431)
|
|
call check_close(after%pair_slip_resid, before%pair_slip_resid, 432)
|
|
call check_close(after%pair_fric_resid, before%pair_fric_resid, 433)
|
|
if (after%pair_flip .ne. before%pair_flip) call fail(434)
|
|
end subroutine compare_contact_pair
|
|
|
|
subroutine check_mult_restart(ierr)
|
|
integer, intent(out) :: ierr
|
|
integer :: slot_count
|
|
integer :: active_count
|
|
integer :: released_count
|
|
integer :: open_count
|
|
integer :: duplicate_count
|
|
integer :: invalid_count
|
|
integer :: state_slots
|
|
integer :: state_open
|
|
integer :: state_stick
|
|
integer :: state_slip
|
|
integer :: state_restick
|
|
integer :: state_separating
|
|
integer :: state_failed
|
|
integer :: al_update_before
|
|
integer :: al_update_after
|
|
real(rk) :: mult_resid_before
|
|
real(rk) :: mult_resid_after
|
|
real(rk) :: max_lambda
|
|
real(rk) :: max_gap
|
|
real(rk) :: max_commit_error
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call contact_multiplier_store_trial(1, 10, 2, 20, 3, 1, 7.0_rk, &
|
|
0.03_rk, .true., ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call contact_multiplier_commit()
|
|
call contact_multiplier_store_trial(1, 10, 2, 20, 3, 1, ZERO, &
|
|
0.01_rk, .false., ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call contact_multiplier_store_trial(1, 11, 2, 20, 3, 1, 9.0_rk, &
|
|
0.04_rk, .true., ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call contact_multiplier_store_trial(1, 12, 2, 20, 3, 1, ZERO, &
|
|
0.02_rk, .false., ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call contact_multiplier_commit()
|
|
call contact_multiplier_audit(slot_count, active_count, &
|
|
released_count, open_count, duplicate_count, invalid_count, &
|
|
max_lambda, max_gap, max_commit_error, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (slot_count .ne. 3) call fail(28)
|
|
if (active_count .ne. 1) call fail(29)
|
|
if (released_count .ne. 1) call fail(30)
|
|
if (open_count .ne. 1) call fail(31)
|
|
if (duplicate_count .ne. 0 .or. invalid_count .ne. 0) call fail(32)
|
|
call contact_multiplier_state_counts(state_slots, state_open, &
|
|
state_stick, state_slip, state_restick, state_separating, &
|
|
state_failed, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (state_slots .ne. 3) call fail(380)
|
|
if (state_open .ne. 1) call fail(381)
|
|
if (state_stick .ne. 1) call fail(382)
|
|
if (state_slip + state_restick + state_failed .ne. 0) call fail(383)
|
|
if (state_separating .ne. 1) call fail(384)
|
|
call contact_multiplier_resid_stats(mult_resid_before, &
|
|
al_update_before, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call check_close(mult_resid_before, ZERO, 391)
|
|
if (al_update_before .ne. 0) call fail(392)
|
|
call check_close(max_lambda, 9.0_rk, 33)
|
|
call check_close(max_gap, 0.04_rk, 34)
|
|
call check_close(max_commit_error, ZERO, 35)
|
|
call fem_write_restart(MULT_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call contact_multiplier_stats(slot_count, active_count, max_lambda, max_gap)
|
|
if (slot_count .ne. 0) call fail(23)
|
|
call contact_multiplier_state_counts(state_slots, state_open, &
|
|
state_stick, state_slip, state_restick, state_separating, &
|
|
state_failed, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (state_slots .ne. 0) call fail(385)
|
|
|
|
call fem_read_restart(MULT_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call contact_multiplier_stats(slot_count, active_count, max_lambda, max_gap)
|
|
if (slot_count .ne. 3) call fail(24)
|
|
if (active_count .ne. 1) call fail(25)
|
|
call check_close(max_lambda, 9.0_rk, 26)
|
|
call check_close(max_gap, 0.04_rk, 27)
|
|
call contact_multiplier_audit(slot_count, active_count, &
|
|
released_count, open_count, duplicate_count, invalid_count, &
|
|
max_lambda, max_gap, max_commit_error, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (released_count .ne. 1) call fail(36)
|
|
if (open_count .ne. 1) call fail(37)
|
|
if (duplicate_count .ne. 0 .or. invalid_count .ne. 0) call fail(38)
|
|
call contact_multiplier_state_counts(state_slots, state_open, &
|
|
state_stick, state_slip, state_restick, state_separating, &
|
|
state_failed, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (state_slots .ne. 3) call fail(386)
|
|
if (state_open .ne. 1) call fail(387)
|
|
if (state_stick .ne. 1) call fail(388)
|
|
if (state_separating .ne. 1) call fail(389)
|
|
if (state_slip + state_restick + state_failed .ne. 0) call fail(390)
|
|
call contact_multiplier_resid_stats(mult_resid_after, al_update_after, &
|
|
ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call check_close(mult_resid_after, mult_resid_before, 393)
|
|
if (al_update_after .ne. al_update_before) call fail(394)
|
|
call check_close(max_commit_error, ZERO, 39)
|
|
end subroutine check_mult_restart
|
|
|
|
subroutine check_shell_rotation_restart(ierr)
|
|
integer, intent(out) :: ierr
|
|
real(rk) :: theta
|
|
real(rk) :: q_before(4)
|
|
real(rk) :: q_after(4)
|
|
real(rk) :: vec(NDIM)
|
|
real(rk) :: rotated(NDIM)
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call shell_rotation_ensure(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
theta = 4.0_rk * atan(ONE) / 3.0_rk
|
|
q_before = ZERO
|
|
q_before(1) = cos(HALF * theta)
|
|
q_before(3) = sin(HALF * theta)
|
|
call shell_rotation_set_committed(2, q_before, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_write_restart(ROT_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_read_restart(ROT_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call shell_rotation_get_committed(2, q_after, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call check_vector4(q_after, q_before, 41)
|
|
|
|
vec = (/ ZERO, ZERO, ONE /)
|
|
call shell_rotation_rotate_vector(2, vec, rotated, ierr, .false.)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call check_close(rotated(1), sin(theta), 42)
|
|
call check_close(rotated(2), ZERO, 43)
|
|
call check_close(rotated(3), cos(theta), 44)
|
|
end subroutine check_shell_rotation_restart
|
|
|
|
subroutine check_lifecycle_restart(ierr)
|
|
integer, intent(out) :: ierr
|
|
integer :: step_before
|
|
integer :: increment_before
|
|
integer :: iteration_before
|
|
integer :: event_before
|
|
integer :: reason_before
|
|
integer :: audit_before
|
|
integer :: begin_before
|
|
integer :: rollback_req_before
|
|
integer :: rollback_ok_before
|
|
integer :: rollback_fail_before
|
|
integer :: commit_before
|
|
integer :: step_after
|
|
integer :: increment_after
|
|
integer :: iteration_after
|
|
integer :: event_after
|
|
integer :: reason_after
|
|
integer :: audit_after
|
|
integer :: begin_after
|
|
integer :: rollback_req_after
|
|
integer :: rollback_ok_after
|
|
integer :: rollback_fail_after
|
|
integer :: commit_after
|
|
real(rk) :: load_before
|
|
real(rk) :: arc_before
|
|
real(rk) :: load_after
|
|
real(rk) :: arc_after
|
|
logical :: path_before
|
|
logical :: path_after
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call nl_lifecycle_reset()
|
|
call nl_lifecycle_begin_increment(7, 2)
|
|
call nl_lifecycle_record_audit(NLC_AUDIT_COMMIT_OK)
|
|
call nl_lifecycle_record_arc_state(1.25_rk, 2.5e-3_rk)
|
|
call nl_lifecycle_mark_path_appended(.true.)
|
|
call nl_lifecycle_record_event(7, 2, 3, NLC_EVENT_COMMIT, NFAIL_NONE)
|
|
call nl_lifecycle_record_event(7, 2, 3, NLC_EVENT_ACCEPT, NFAIL_NONE)
|
|
call capture_lifecycle(step_before, increment_before, iteration_before, &
|
|
event_before, reason_before, audit_before, begin_before, &
|
|
rollback_req_before, rollback_ok_before, rollback_fail_before, &
|
|
commit_before, load_before, arc_before, path_before, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (event_before .ne. NLC_EVENT_ACCEPT) call fail(501)
|
|
if (audit_before .ne. NLC_AUDIT_COMMIT_OK) call fail(502)
|
|
if (commit_before .ne. 1) call fail(503)
|
|
|
|
call fem_write_restart(LIFECYCLE_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(520)
|
|
call write_restart_without_lifecycle(LIFECYCLE_RESTART_FILE, &
|
|
LEGACY_LIFECYCLE_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(521)
|
|
call write_restart_bad_lifecycle(LIFECYCLE_RESTART_FILE, &
|
|
BAD_LIFECYCLE_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(524)
|
|
call nl_lifecycle_reset()
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_read_restart(LIFECYCLE_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail(522)
|
|
call capture_lifecycle(step_after, increment_after, iteration_after, &
|
|
event_after, reason_after, audit_after, begin_after, rollback_req_after, &
|
|
rollback_ok_after, rollback_fail_after, commit_after, load_after, &
|
|
arc_after, path_after, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
if (step_after .ne. step_before) call fail(504)
|
|
if (increment_after .ne. increment_before) call fail(505)
|
|
if (iteration_after .ne. iteration_before) call fail(506)
|
|
if (event_after .ne. event_before) call fail(507)
|
|
if (reason_after .ne. reason_before) call fail(508)
|
|
if (audit_after .ne. audit_before) call fail(509)
|
|
if (begin_after .ne. begin_before) call fail(510)
|
|
if (rollback_req_after .ne. rollback_req_before) call fail(511)
|
|
if (rollback_ok_after .ne. rollback_ok_before) call fail(512)
|
|
if (rollback_fail_after .ne. rollback_fail_before) call fail(513)
|
|
if (commit_after .ne. commit_before) call fail(514)
|
|
call check_close(load_after, load_before, 515)
|
|
call check_close(arc_after, arc_before, 516)
|
|
if (path_after .neqv. path_before) call fail(517)
|
|
|
|
call nl_lifecycle_reset()
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_read_restart(LEGACY_LIFECYCLE_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) call fail_with_last_error(523)
|
|
call capture_lifecycle(step_after, increment_after, iteration_after, &
|
|
event_after, reason_after, audit_after, begin_after, rollback_req_after, &
|
|
rollback_ok_after, rollback_fail_after, commit_after, load_after, &
|
|
arc_after, path_after, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (event_after .ne. NLC_EVENT_NONE) call fail(518)
|
|
if (audit_after .ne. NLC_AUDIT_NONE) call fail(519)
|
|
if (step_after .ne. 0 .or. increment_after .ne. 0) call fail(525)
|
|
if (path_after) call fail(526)
|
|
|
|
call nl_lifecycle_reset()
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_read_restart(BAD_LIFECYCLE_RESTART_FILE, ierr)
|
|
if (ierr .eq. FEM_SUCCESS) call fail(527)
|
|
call error_clear(ierr)
|
|
end subroutine check_lifecycle_restart
|
|
|
|
subroutine check_restart_each_accept(ierr)
|
|
integer, intent(out) :: ierr
|
|
integer :: accepted
|
|
integer :: step_before
|
|
integer :: increment_before
|
|
integer :: iteration_before
|
|
integer :: event_before
|
|
integer :: reason_before
|
|
integer :: audit_before
|
|
integer :: begin_before
|
|
integer :: rollback_req_before
|
|
integer :: rollback_ok_before
|
|
integer :: rollback_fail_before
|
|
integer :: commit_before
|
|
integer :: step_after
|
|
integer :: increment_after
|
|
integer :: iteration_after
|
|
integer :: event_after
|
|
integer :: reason_after
|
|
integer :: audit_after
|
|
integer :: begin_after
|
|
integer :: rollback_req_after
|
|
integer :: rollback_ok_after
|
|
integer :: rollback_fail_after
|
|
integer :: commit_after
|
|
integer :: final_step
|
|
real(rk) :: load_before
|
|
real(rk) :: arc_before
|
|
real(rk) :: load_after
|
|
real(rk) :: arc_after
|
|
real(rk) :: final_time
|
|
logical :: path_before
|
|
logical :: path_after
|
|
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
do accepted = 1, 2
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call mark_restart_audit_accept(accepted)
|
|
call capture_lifecycle(step_before, increment_before, &
|
|
iteration_before, event_before, reason_before, audit_before, &
|
|
begin_before, rollback_req_before, rollback_ok_before, &
|
|
rollback_fail_before, commit_before, load_before, arc_before, &
|
|
path_before, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call fem_write_restart(EACH_ACCEPT_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call prepare_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_read_restart(EACH_ACCEPT_RESTART_FILE, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call capture_lifecycle(step_after, increment_after, iteration_after, &
|
|
event_after, reason_after, audit_after, begin_after, &
|
|
rollback_req_after, rollback_ok_after, rollback_fail_after, &
|
|
commit_after, load_after, arc_after, path_after, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
|
|
call compare_lifecycle_capture(step_before, increment_before, &
|
|
iteration_before, event_before, reason_before, audit_before, &
|
|
begin_before, rollback_req_before, rollback_ok_before, &
|
|
rollback_fail_before, commit_before, load_before, arc_before, &
|
|
path_before, step_after, increment_after, iteration_after, &
|
|
event_after, reason_after, audit_after, begin_after, &
|
|
rollback_req_after, rollback_ok_after, rollback_fail_after, &
|
|
commit_after, load_after, arc_after, path_after, 520 + accepted)
|
|
end do
|
|
|
|
call loaded_step(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_current_time(final_time, final_step, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
if (final_step .ne. 3) call fail(529)
|
|
ierr = FEM_SUCCESS
|
|
end subroutine check_restart_each_accept
|
|
|
|
subroutine mark_restart_audit_accept(accepted)
|
|
integer, intent(in) :: accepted
|
|
|
|
call nl_lifecycle_begin_increment(accepted, accepted)
|
|
call nl_lifecycle_record_audit(NLC_AUDIT_BEGIN_TRIAL)
|
|
call nl_lifecycle_record_audit(NLC_AUDIT_COMMIT_OK)
|
|
call nl_lifecycle_record_arc_state(ONE, ZERO)
|
|
call nl_lifecycle_mark_path_appended(.true.)
|
|
call nl_lifecycle_record_event(accepted, accepted, 1, NLC_EVENT_ACCEPT, &
|
|
NFAIL_NONE)
|
|
end subroutine mark_restart_audit_accept
|
|
|
|
subroutine compare_lifecycle_capture(step_before, increment_before, &
|
|
iteration_before, event_before, reason_before, audit_before, &
|
|
begin_before, rollback_req_before, rollback_ok_before, &
|
|
rollback_fail_before, commit_before, load_before, arc_before, &
|
|
path_before, step_after, increment_after, iteration_after, event_after, &
|
|
reason_after, audit_after, begin_after, rollback_req_after, &
|
|
rollback_ok_after, rollback_fail_after, commit_after, load_after, &
|
|
arc_after, path_after, code)
|
|
integer, intent(in) :: step_before
|
|
integer, intent(in) :: increment_before
|
|
integer, intent(in) :: iteration_before
|
|
integer, intent(in) :: event_before
|
|
integer, intent(in) :: reason_before
|
|
integer, intent(in) :: audit_before
|
|
integer, intent(in) :: begin_before
|
|
integer, intent(in) :: rollback_req_before
|
|
integer, intent(in) :: rollback_ok_before
|
|
integer, intent(in) :: rollback_fail_before
|
|
integer, intent(in) :: commit_before
|
|
integer, intent(in) :: step_after
|
|
integer, intent(in) :: increment_after
|
|
integer, intent(in) :: iteration_after
|
|
integer, intent(in) :: event_after
|
|
integer, intent(in) :: reason_after
|
|
integer, intent(in) :: audit_after
|
|
integer, intent(in) :: begin_after
|
|
integer, intent(in) :: rollback_req_after
|
|
integer, intent(in) :: rollback_ok_after
|
|
integer, intent(in) :: rollback_fail_after
|
|
integer, intent(in) :: commit_after
|
|
integer, intent(in) :: code
|
|
real(rk), intent(in) :: load_before
|
|
real(rk), intent(in) :: arc_before
|
|
real(rk), intent(in) :: load_after
|
|
real(rk), intent(in) :: arc_after
|
|
logical, intent(in) :: path_before
|
|
logical, intent(in) :: path_after
|
|
|
|
if (step_after .ne. step_before) call fail(code)
|
|
if (increment_after .ne. increment_before) call fail(code + 10)
|
|
if (iteration_after .ne. iteration_before) call fail(code + 20)
|
|
if (event_after .ne. event_before) call fail(code + 30)
|
|
if (reason_after .ne. reason_before) call fail(code + 40)
|
|
if (audit_after .ne. audit_before) call fail(code + 50)
|
|
if (begin_after .ne. begin_before) call fail(code + 60)
|
|
if (rollback_req_after .ne. rollback_req_before) call fail(code + 70)
|
|
if (rollback_ok_after .ne. rollback_ok_before) call fail(code + 80)
|
|
if (rollback_fail_after .ne. rollback_fail_before) call fail(code + 90)
|
|
if (commit_after .ne. commit_before) call fail(code + 100)
|
|
call check_close(load_after, load_before, code + 110)
|
|
call check_close(arc_after, arc_before, code + 120)
|
|
if (path_after .neqv. path_before) call fail(code + 130)
|
|
end subroutine compare_lifecycle_capture
|
|
|
|
subroutine write_restart_without_lifecycle(source_file, target_file, ierr)
|
|
character(len=*), intent(in) :: source_file
|
|
character(len=*), intent(in) :: target_file
|
|
integer, intent(out) :: ierr
|
|
|
|
call copy_restart_lifecycle(source_file, target_file, 0, ierr)
|
|
end subroutine write_restart_without_lifecycle
|
|
|
|
subroutine write_restart_bad_lifecycle(source_file, target_file, ierr)
|
|
character(len=*), intent(in) :: source_file
|
|
character(len=*), intent(in) :: target_file
|
|
integer, intent(out) :: ierr
|
|
|
|
call copy_restart_lifecycle(source_file, target_file, 1, ierr)
|
|
end subroutine write_restart_bad_lifecycle
|
|
|
|
subroutine copy_restart_lifecycle(source_file, target_file, mode, ierr)
|
|
character(len=*), intent(in) :: source_file
|
|
character(len=*), intent(in) :: target_file
|
|
integer, intent(in) :: mode
|
|
integer, intent(out) :: ierr
|
|
character(len=4096) :: line
|
|
character(len=32) :: tag
|
|
integer :: read_unit
|
|
integer :: write_unit
|
|
integer :: ios_read
|
|
integer :: ios_write
|
|
integer :: ios_tag
|
|
|
|
read_unit = 72
|
|
write_unit = 73
|
|
open(unit=read_unit, file=trim(source_file), status='old', &
|
|
action='read', iostat=ios_read)
|
|
if (ios_read .ne. 0) then
|
|
ierr = FEM_ERR_OUTPUT
|
|
return
|
|
end if
|
|
open(unit=write_unit, file=trim(target_file), status='replace', &
|
|
action='write', iostat=ios_write)
|
|
if (ios_write .ne. 0) then
|
|
close(read_unit)
|
|
ierr = FEM_ERR_OUTPUT
|
|
return
|
|
end if
|
|
|
|
do
|
|
read(read_unit,'(A)',iostat=ios_read) line
|
|
if (ios_read .ne. 0) exit
|
|
tag = ' '
|
|
read(line,*,iostat=ios_tag) tag
|
|
if (ios_tag .eq. 0 .and. trim(tag) .eq. 'LIFECYCLE_DIAGNOSTICS') then
|
|
if (mode .eq. 0) cycle
|
|
write(write_unit,'(A)',iostat=ios_write) &
|
|
'LIFECYCLE_DIAGNOSTICS 1 2'
|
|
if (ios_write .ne. 0) exit
|
|
cycle
|
|
end if
|
|
write(write_unit,'(A)',iostat=ios_write) trim(line)
|
|
if (ios_write .ne. 0) exit
|
|
end do
|
|
|
|
close(read_unit)
|
|
close(write_unit)
|
|
if (ios_write .ne. 0) then
|
|
ierr = FEM_ERR_OUTPUT
|
|
else if (ios_read .lt. 0) then
|
|
ierr = FEM_SUCCESS
|
|
else
|
|
ierr = FEM_ERR_OUTPUT
|
|
end if
|
|
end subroutine copy_restart_lifecycle
|
|
|
|
subroutine capture_lifecycle(step, increment, iteration, event_id, &
|
|
reason_id, audit_status, begin_trial_count, &
|
|
rollback_requested_count, rollback_ok_count, &
|
|
rollback_failed_count, commit_ok_count, &
|
|
load_factor, arc_residual, path_appended, ierr)
|
|
integer, intent(out) :: step
|
|
integer, intent(out) :: increment
|
|
integer, intent(out) :: iteration
|
|
integer, intent(out) :: event_id
|
|
integer, intent(out) :: reason_id
|
|
integer, intent(out) :: audit_status
|
|
integer, intent(out) :: begin_trial_count
|
|
integer, intent(out) :: rollback_requested_count
|
|
integer, intent(out) :: rollback_ok_count
|
|
integer, intent(out) :: rollback_failed_count
|
|
integer, intent(out) :: commit_ok_count
|
|
real(rk), intent(out) :: load_factor
|
|
real(rk), intent(out) :: arc_residual
|
|
logical, intent(out) :: path_appended
|
|
integer, intent(out) :: ierr
|
|
character(len=64) :: event_name
|
|
character(len=64) :: reason_name
|
|
character(len=64) :: audit_name
|
|
|
|
call fem_get_nl_lifecycle_snapshot(step, increment, iteration, event_id, &
|
|
event_name, reason_id, reason_name, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_nl_lifecycle_arc(load_factor, arc_residual, path_appended, &
|
|
ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_nl_lifecycle_audit(audit_status, audit_name, &
|
|
begin_trial_count, rollback_requested_count, rollback_ok_count, &
|
|
rollback_failed_count, commit_ok_count, ierr)
|
|
end subroutine capture_lifecycle
|
|
|
|
subroutine prepare_contact_model(ierr)
|
|
integer, intent(out) :: ierr
|
|
|
|
call fem_read_inp('examples/contact_block_sliding/block_sliding_friction.inp', &
|
|
ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_build_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_compute_lumped_mass(ierr)
|
|
end subroutine prepare_contact_model
|
|
|
|
subroutine run_contact_steps(step_count, ierr)
|
|
integer, intent(in) :: step_count
|
|
integer, intent(out) :: ierr
|
|
integer :: step
|
|
|
|
do step = 1, step_count
|
|
call fem_advance_explicit(DT_CONTACT, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
end do
|
|
|
|
ierr = FEM_SUCCESS
|
|
end subroutine run_contact_steps
|
|
|
|
subroutine check_vector(actual, expected, code)
|
|
real(rk), intent(in) :: actual(NDIM)
|
|
real(rk), intent(in) :: expected(NDIM)
|
|
integer, intent(in) :: code
|
|
integer :: idir
|
|
|
|
do idir = 1, NDIM
|
|
call check_close(actual(idir), expected(idir), code)
|
|
end do
|
|
end subroutine check_vector
|
|
|
|
subroutine check_vector4(actual, expected, code)
|
|
real(rk), intent(in) :: actual(4)
|
|
real(rk), intent(in) :: expected(4)
|
|
integer, intent(in) :: code
|
|
integer :: i
|
|
|
|
do i = 1, 4
|
|
call check_close(actual(i), expected(i), code)
|
|
end do
|
|
end subroutine check_vector4
|
|
|
|
subroutine check_close(actual, expected, code)
|
|
real(rk), intent(in) :: actual
|
|
real(rk), intent(in) :: expected
|
|
integer, intent(in) :: code
|
|
real(rk) :: scale
|
|
|
|
scale = max(ONE, abs(expected))
|
|
if (abs(actual - expected) .gt. 1.0e-8_rk * scale) call fail(code)
|
|
end subroutine check_close
|
|
|
|
subroutine fail_with_last_error(code)
|
|
integer, intent(in) :: code
|
|
integer :: ierr
|
|
integer :: err_code
|
|
character(len=256) :: message
|
|
|
|
call fem_get_last_error(err_code, message, ierr)
|
|
write(*,*) 'last error:', err_code, trim(message)
|
|
call fail(code)
|
|
end subroutine fail_with_last_error
|
|
|
|
subroutine fail(code)
|
|
integer, intent(in) :: code
|
|
|
|
write(*,*) 'test_restart failed:', code
|
|
stop 1
|
|
end subroutine fail
|
|
|
|
end program test_restart
|