diff --git a/CMakeLists.txt b/CMakeLists.txt index ec7e246..a27d3ba 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -85,6 +85,7 @@ set(SPHLITE_CORE_SOURCES src/explosive/sph_explosive_helpers.f90 src/explosive/sph_explosive.f90 src/solid/sph_solid_state.f90 + src/solid/sph_solid_material.f90 src/solid/sph_solid.f90 src/shell/sph_shell.f90 src/interface/sph_api_state.f90 @@ -182,6 +183,30 @@ set_target_properties(test_solid_state_build PROPERTIES Fortran_MODULE_DIRECTORY add_test(NAME solid_state_build COMMAND test_solid_state_build) set_tests_properties(solid_state_build PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_executable(test_solid_elastic_material tests/module/test_solid_elastic_material.f90) +target_link_libraries(test_solid_elastic_material PRIVATE sphlite_core) +set_target_properties(test_solid_elastic_material PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME solid_elastic_material COMMAND test_solid_elastic_material) +set_tests_properties(solid_elastic_material PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + +add_executable(test_solid_johnson_cook_flow tests/module/test_solid_johnson_cook_flow.f90) +target_link_libraries(test_solid_johnson_cook_flow PRIVATE sphlite_core) +set_target_properties(test_solid_johnson_cook_flow PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME solid_johnson_cook_flow COMMAND test_solid_johnson_cook_flow) +set_tests_properties(solid_johnson_cook_flow PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + +add_executable(test_solid_johnson_cook_failure tests/module/test_solid_johnson_cook_failure.f90) +target_link_libraries(test_solid_johnson_cook_failure PRIVATE sphlite_core) +set_target_properties(test_solid_johnson_cook_failure PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME solid_johnson_cook_failure COMMAND test_solid_johnson_cook_failure) +set_tests_properties(solid_johnson_cook_failure PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + +add_executable(test_solid_progressive_softening tests/module/test_solid_progressive_softening.f90) +target_link_libraries(test_solid_progressive_softening PRIVATE sphlite_core) +set_target_properties(test_solid_progressive_softening PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME solid_progressive_softening COMMAND test_solid_progressive_softening) +set_tests_properties(solid_progressive_softening PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_executable(test_c_api tests/interface/test_c_api.c) target_include_directories(test_c_api PRIVATE include) target_compile_definitions(test_c_api PRIVATE diff --git a/src/solid/sph_solid.f90 b/src/solid/sph_solid.f90 index d6ffb7f..286f0be 100644 --- a/src/solid/sph_solid.f90 +++ b/src/solid/sph_solid.f90 @@ -5,8 +5,14 @@ module sph_solid use sph_database, only: SPH_MAX_MATERIALS, SPH_NAME_LEN, material_count, & material_name, material_type, material_density, npart, particle_phase, & particle_status, material_id, rho, temperature, internal_energy, & - SPH_PHASE_SOLID, SPH_STATUS_ACTIVE + SPH_PHASE_SOLID, SPH_PHASE_SOLID_FAILED, SPH_STATUS_ACTIVE, & + SPH_STATUS_FAILED use sph_solid_state + use sph_solid_material, only: sph_solid_elastic_constants, & + sph_solid_elastic_trial, sph_solid_jc_return_mapping, & + sph_solid_internal_energy_increment, sph_solid_von_mises, & + sph_solid_mean_stress, sph_solid_jc_failure_strain, & + sph_solid_damage_update, sph_solid_linear_softening implicit none logical :: solid_module_initialized = .false. @@ -291,10 +297,10 @@ contains if (density_value <= 0.0_rk) cycle e_value = solid_elastic_e(solid_index) nu_value = solid_elastic_nu(solid_index) - solid_shear_modulus(solid_index) = e_value / (2.0_rk * (1.0_rk + nu_value)) - solid_bulk_modulus(solid_index) = e_value / (3.0_rk * (1.0_rk - 2.0_rk * nu_value)) - solid_wave_speed(solid_index) = sqrt((solid_bulk_modulus(solid_index) + & - 4.0_rk * solid_shear_modulus(solid_index) / 3.0_rk) / density_value) + call sph_solid_elastic_constants(e_value, nu_value, density_value, & + solid_shear_modulus(solid_index), solid_bulk_modulus(solid_index), & + solid_wave_speed(solid_index), ierr) + if (ierr /= SPH_SUCCESS) return end do end subroutine sph_solid_update_material_state @@ -384,6 +390,138 @@ contains end do end subroutine sph_solid_initialize_particle_state + subroutine sph_solid_update_particle_material(index, strain_inc, dt, ierr) + integer, intent(in) :: index + real(rk), intent(in) :: strain_inc(6) + real(rk), intent(in) :: dt + integer, intent(out) :: ierr + integer :: solid_index + integer :: failure_status + real(rk) :: stress_old(6) + real(rk) :: stress_new(6) + real(rk) :: jc_params(5) + real(rk) :: jc_refs(3) + real(rk) :: ep_old + real(rk) :: ep_new + real(rk) :: ep_rate_new + real(rk) :: plastic_delta + real(rk) :: plastic_work + real(rk) :: temp_old + real(rk) :: temp_new + real(rk) :: energy_inc + real(rk) :: density_value + real(rk) :: seq_value + real(rk) :: triaxiality + real(rk) :: failure_strain + real(rk) :: damage_new + real(rk) :: softening_width + + ierr = SPH_SUCCESS + if (index < 1 .or. index > npart) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid particle index is out of range') + ierr = SPH_ERROR_ARGUMENT + return + end if + if (.not. allocated(solid_stress)) then + call sph_error_set(SPH_ERROR_INPUT, 'Solid state is not allocated') + ierr = SPH_ERROR_INPUT + return + end if + if (particle_phase(index) == SPH_PHASE_SOLID_FAILED) return + if (particle_phase(index) /= SPH_PHASE_SOLID) return + if (particle_status(index) /= SPH_STATUS_ACTIVE) return + solid_index = sph_solid_table_index_by_material_id(material_id(index)) + if (solid_index <= 0) then + call sph_error_set(SPH_ERROR_INPUT, 'Solid particle material has no state') + ierr = SPH_ERROR_INPUT + return + end if + + stress_old = solid_stress(:,index) + ep_old = solid_plastic_strain(index) + ep_new = ep_old + ep_rate_new = 0.0_rk + plastic_delta = 0.0_rk + plastic_work = 0.0_rk + temp_old = solid_temperature(index) + temp_new = temp_old + if (solid_johnson_cook_defined(solid_index)) then + jc_params = (/ solid_jc_a(solid_index), solid_jc_b(solid_index), & + solid_jc_n(solid_index), solid_jc_c(solid_index), solid_jc_m(solid_index) /) + jc_refs = (/ solid_jc_epsdot0(solid_index), solid_jc_troom(solid_index), & + solid_jc_tmelt(solid_index) /) + call sph_solid_jc_return_mapping(stress_old, strain_inc, & + solid_shear_modulus(solid_index), solid_bulk_modulus(solid_index), & + dt, jc_params, jc_refs, temp_old, ep_old, & + solid_temperature_rise_factor(solid_index), stress_new, ep_new, & + ep_rate_new, plastic_work, temp_new, plastic_delta, ierr) + else + call sph_solid_elastic_trial(stress_old, strain_inc, & + solid_shear_modulus(solid_index), solid_bulk_modulus(solid_index), & + stress_new, ierr) + end if + if (ierr /= SPH_SUCCESS) return + + density_value = rho(index) + if (density_value <= 0.0_rk) density_value = solid_density(solid_index) + call sph_solid_internal_energy_increment(stress_old, stress_new, strain_inc, & + density_value, energy_inc, ierr) + if (ierr /= SPH_SUCCESS) return + + if (solid_failure_defined(solid_index) .and. plastic_delta > 0.0_rk) then + seq_value = sph_solid_von_mises(stress_new) + triaxiality = 0.0_rk + if (seq_value > 0.0_rk) triaxiality = sph_solid_mean_stress(stress_new) / seq_value + call sph_solid_jc_failure_strain(solid_failure_d(:,solid_index), & + triaxiality, ep_rate_new, solid_jc_epsdot0(solid_index), temp_new, & + solid_jc_troom(solid_index), solid_jc_tmelt(solid_index), & + failure_strain, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_solid_damage_update(solid_damage(index), plastic_delta, & + failure_strain, damage_new, failure_status, ierr) + if (ierr /= SPH_SUCCESS) return + solid_damage(index) = damage_new + softening_width = solid_softening_width(solid_index) + if (softening_width <= 0.0_rk) softening_width = 1.0_rk + call sph_solid_linear_softening(solid_damage(index), softening_width, & + solid_softening(index), ierr) + if (ierr /= SPH_SUCCESS) return + if (failure_status == SPH_STATUS_FAILED) then + call sph_solid_mark_particle_failed(index, ierr) + if (ierr /= SPH_SUCCESS) return + end if + end if + + solid_stress(:,index) = solid_softening(index) * stress_new + solid_strain(:,index) = solid_strain(:,index) + strain_inc + solid_plastic_strain(index) = ep_new + solid_plastic_strain_rate(index) = ep_rate_new + solid_temperature(index) = temp_new + solid_internal_energy(index) = solid_internal_energy(index) + energy_inc + end subroutine sph_solid_update_particle_material + + subroutine sph_solid_mark_particle_failed(index, ierr) + integer, intent(in) :: index + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + if (index < 1 .or. index > npart) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid failed particle index is out of range') + ierr = SPH_ERROR_ARGUMENT + return + end if + if (.not. allocated(solid_failure_status)) then + call sph_error_set(SPH_ERROR_INPUT, 'Solid failure state is not allocated') + ierr = SPH_ERROR_INPUT + return + end if + solid_failure_status(index) = SPH_STATUS_FAILED + solid_damage(index) = 1.0_rk + solid_softening(index) = 0.0_rk + particle_status(index) = SPH_STATUS_FAILED + particle_phase(index) = SPH_PHASE_SOLID_FAILED + end subroutine sph_solid_mark_particle_failed + integer function sph_solid_register_material(name) character(len=*), intent(in) :: name integer :: existing diff --git a/src/solid/sph_solid_material.f90 b/src/solid/sph_solid_material.f90 new file mode 100644 index 0000000..b78b5b5 --- /dev/null +++ b/src/solid/sph_solid_material.f90 @@ -0,0 +1,373 @@ +module sph_solid_material + use sph_precision, only: rk + use sph_error, only: SPH_SUCCESS, SPH_ERROR_ARGUMENT, sph_error_set + use sph_database, only: SPH_STATUS_ACTIVE, SPH_STATUS_FAILED + implicit none + +contains + + subroutine sph_solid_elastic_constants(e_value, nu_value, density_value, & + shear, bulk, wave_speed, ierr) + real(rk), intent(in) :: e_value + real(rk), intent(in) :: nu_value + real(rk), intent(in) :: density_value + real(rk), intent(out) :: shear + real(rk), intent(out) :: bulk + real(rk), intent(out) :: wave_speed + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + shear = 0.0_rk + bulk = 0.0_rk + wave_speed = 0.0_rk + if (e_value <= 0.0_rk .or. density_value <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid elastic constants require positive E and density') + ierr = SPH_ERROR_ARGUMENT + return + end if + if (nu_value <= -1.0_rk .or. nu_value >= 0.5_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid elastic constants require valid Poisson ratio') + ierr = SPH_ERROR_ARGUMENT + return + end if + shear = e_value / (2.0_rk * (1.0_rk + nu_value)) + bulk = e_value / (3.0_rk * (1.0_rk - 2.0_rk * nu_value)) + wave_speed = sqrt((bulk + 4.0_rk * shear / 3.0_rk) / density_value) + end subroutine sph_solid_elastic_constants + + subroutine sph_solid_elastic_trial(stress_old, strain_inc, shear, bulk, & + stress_new, ierr) + real(rk), intent(in) :: stress_old(6) + real(rk), intent(in) :: strain_inc(6) + real(rk), intent(in) :: shear + real(rk), intent(in) :: bulk + real(rk), intent(out) :: stress_new(6) + integer, intent(out) :: ierr + real(rk) :: lambda + real(rk) :: trace_inc + + ierr = SPH_SUCCESS + stress_new = stress_old + if (shear <= 0.0_rk .or. bulk <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid elastic update requires positive constants') + ierr = SPH_ERROR_ARGUMENT + return + end if + lambda = bulk - 2.0_rk * shear / 3.0_rk + trace_inc = strain_inc(1) + strain_inc(2) + strain_inc(3) + stress_new(1) = stress_new(1) + 2.0_rk * shear * strain_inc(1) + lambda * trace_inc + stress_new(2) = stress_new(2) + 2.0_rk * shear * strain_inc(2) + lambda * trace_inc + stress_new(3) = stress_new(3) + 2.0_rk * shear * strain_inc(3) + lambda * trace_inc + stress_new(4) = stress_new(4) + 2.0_rk * shear * strain_inc(4) + stress_new(5) = stress_new(5) + 2.0_rk * shear * strain_inc(5) + stress_new(6) = stress_new(6) + 2.0_rk * shear * strain_inc(6) + end subroutine sph_solid_elastic_trial + + real(rk) function sph_solid_von_mises(stress) + real(rk), intent(in) :: stress(6) + real(rk) :: mean_stress + real(rk) :: dev(3) + real(rk) :: shear_part + + mean_stress = (stress(1) + stress(2) + stress(3)) / 3.0_rk + dev(1) = stress(1) - mean_stress + dev(2) = stress(2) - mean_stress + dev(3) = stress(3) - mean_stress + shear_part = stress(4) * stress(4) + stress(5) * stress(5) + stress(6) * stress(6) + sph_solid_von_mises = sqrt(1.5_rk * (sum(dev * dev) + 2.0_rk * shear_part)) + end function sph_solid_von_mises + + real(rk) function sph_solid_mean_stress(stress) + real(rk), intent(in) :: stress(6) + + sph_solid_mean_stress = (stress(1) + stress(2) + stress(3)) / 3.0_rk + end function sph_solid_mean_stress + + real(rk) function sph_solid_equiv_plastic_strain_rate(delta_ep, dt) + real(rk), intent(in) :: delta_ep + real(rk), intent(in) :: dt + + sph_solid_equiv_plastic_strain_rate = 0.0_rk + if (dt > 0.0_rk .and. delta_ep > 0.0_rk) then + sph_solid_equiv_plastic_strain_rate = delta_ep / dt + end if + end function sph_solid_equiv_plastic_strain_rate + + subroutine sph_solid_jc_temperature_star(temp, troom, tmelt, tstar, ierr) + real(rk), intent(in) :: temp + real(rk), intent(in) :: troom + real(rk), intent(in) :: tmelt + real(rk), intent(out) :: tstar + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + tstar = 0.0_rk + if (tmelt <= troom) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid Johnson-Cook temperature range is invalid') + ierr = SPH_ERROR_ARGUMENT + return + end if + tstar = (temp - troom) / (tmelt - troom) + call sph_solid_clamp_unit(tstar) + end subroutine sph_solid_jc_temperature_star + + subroutine sph_solid_jc_rate_factor(strain_rate, epsdot0, c_value, factor, ierr) + real(rk), intent(in) :: strain_rate + real(rk), intent(in) :: epsdot0 + real(rk), intent(in) :: c_value + real(rk), intent(out) :: factor + integer, intent(out) :: ierr + real(rk) :: ratio + + ierr = SPH_SUCCESS + factor = 1.0_rk + if (epsdot0 <= 0.0_rk .or. c_value < 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid Johnson-Cook rate parameters are invalid') + ierr = SPH_ERROR_ARGUMENT + return + end if + ratio = max(strain_rate / epsdot0, 1.0_rk) + factor = 1.0_rk + c_value * log(ratio) + if (factor < 0.0_rk) factor = 0.0_rk + end subroutine sph_solid_jc_rate_factor + + subroutine sph_solid_jc_hardening(a_value, b_value, n_value, ep, hardening, ierr) + real(rk), intent(in) :: a_value + real(rk), intent(in) :: b_value + real(rk), intent(in) :: n_value + real(rk), intent(in) :: ep + real(rk), intent(out) :: hardening + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + hardening = 0.0_rk + if (a_value < 0.0_rk .or. b_value < 0.0_rk .or. n_value < 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid Johnson-Cook hardening parameters are invalid') + ierr = SPH_ERROR_ARGUMENT + return + end if + hardening = a_value + b_value * max(ep, 0.0_rk)**n_value + end subroutine sph_solid_jc_hardening + + subroutine sph_solid_jc_flow_stress(a_value, b_value, n_value, c_value, & + m_value, epsdot0, troom, tmelt, ep, ep_rate, temp, flow, ierr) + real(rk), intent(in) :: a_value + real(rk), intent(in) :: b_value + real(rk), intent(in) :: n_value + real(rk), intent(in) :: c_value + real(rk), intent(in) :: m_value + real(rk), intent(in) :: epsdot0 + real(rk), intent(in) :: troom + real(rk), intent(in) :: tmelt + real(rk), intent(in) :: ep + real(rk), intent(in) :: ep_rate + real(rk), intent(in) :: temp + real(rk), intent(out) :: flow + integer, intent(out) :: ierr + real(rk) :: hardening + real(rk) :: rate_factor + real(rk) :: tstar + real(rk) :: thermal_factor + + flow = 0.0_rk + call sph_solid_jc_hardening(a_value, b_value, n_value, ep, hardening, ierr) + if (ierr /= SPH_SUCCESS) return + if (m_value < 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid Johnson-Cook thermal exponent is invalid') + ierr = SPH_ERROR_ARGUMENT + return + end if + call sph_solid_jc_rate_factor(ep_rate, epsdot0, c_value, rate_factor, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_solid_jc_temperature_star(temp, troom, tmelt, tstar, ierr) + if (ierr /= SPH_SUCCESS) return + thermal_factor = 1.0_rk - tstar**m_value + if (thermal_factor < 0.0_rk) thermal_factor = 0.0_rk + flow = hardening * rate_factor * thermal_factor + end subroutine sph_solid_jc_flow_stress + + subroutine sph_solid_jc_return_mapping(stress_old, strain_inc, shear, bulk, & + dt, jc_params, jc_refs, temp_old, ep_old, temp_factor, stress_new, & + ep_new, ep_rate_new, plastic_work, temp_new, plastic_delta, ierr) + real(rk), intent(in) :: stress_old(6) + real(rk), intent(in) :: strain_inc(6) + real(rk), intent(in) :: shear + real(rk), intent(in) :: bulk + real(rk), intent(in) :: dt + real(rk), intent(in) :: jc_params(5) + real(rk), intent(in) :: jc_refs(3) + real(rk), intent(in) :: temp_old + real(rk), intent(in) :: ep_old + real(rk), intent(in) :: temp_factor + real(rk), intent(out) :: stress_new(6) + real(rk), intent(out) :: ep_new + real(rk), intent(out) :: ep_rate_new + real(rk), intent(out) :: plastic_work + real(rk), intent(out) :: temp_new + real(rk), intent(out) :: plastic_delta + integer, intent(out) :: ierr + real(rk) :: trial_stress(6) + real(rk) :: seq_trial + real(rk) :: flow + real(rk) :: scale + + ep_new = max(ep_old, 0.0_rk) + ep_rate_new = 0.0_rk + plastic_work = 0.0_rk + plastic_delta = 0.0_rk + temp_new = temp_old + call sph_solid_elastic_trial(stress_old, strain_inc, shear, bulk, trial_stress, ierr) + if (ierr /= SPH_SUCCESS) return + stress_new = trial_stress + seq_trial = sph_solid_von_mises(trial_stress) + call sph_solid_jc_flow_stress(jc_params(1), jc_params(2), jc_params(3), & + jc_params(4), jc_params(5), jc_refs(1), jc_refs(2), jc_refs(3), & + ep_new, 0.0_rk, temp_old, flow, ierr) + if (ierr /= SPH_SUCCESS) return + if (seq_trial <= flow .or. seq_trial <= 0.0_rk) return + plastic_delta = (seq_trial - flow) / (3.0_rk * shear) + if (plastic_delta < 0.0_rk) plastic_delta = 0.0_rk + ep_rate_new = sph_solid_equiv_plastic_strain_rate(plastic_delta, dt) + ep_new = ep_new + plastic_delta + call sph_solid_jc_flow_stress(jc_params(1), jc_params(2), jc_params(3), & + jc_params(4), jc_params(5), jc_refs(1), jc_refs(2), jc_refs(3), & + ep_new, ep_rate_new, temp_old, flow, ierr) + if (ierr /= SPH_SUCCESS) return + scale = flow / seq_trial + if (scale < 0.0_rk) scale = 0.0_rk + if (scale > 1.0_rk) scale = 1.0_rk + call sph_solid_scale_deviatoric(trial_stress, scale, stress_new) + plastic_work = flow * plastic_delta + temp_new = temp_old + temp_factor * plastic_work + end subroutine sph_solid_jc_return_mapping + + subroutine sph_solid_internal_energy_increment(stress_old, stress_new, & + strain_inc, density_value, delta_energy, ierr) + real(rk), intent(in) :: stress_old(6) + real(rk), intent(in) :: stress_new(6) + real(rk), intent(in) :: strain_inc(6) + real(rk), intent(in) :: density_value + real(rk), intent(out) :: delta_energy + integer, intent(out) :: ierr + real(rk) :: stress_avg(6) + + ierr = SPH_SUCCESS + delta_energy = 0.0_rk + if (density_value <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid internal energy requires positive density') + ierr = SPH_ERROR_ARGUMENT + return + end if + stress_avg = 0.5_rk * (stress_old + stress_new) + delta_energy = sph_solid_voigt_dot(stress_avg, strain_inc) / density_value + end subroutine sph_solid_internal_energy_increment + + subroutine sph_solid_jc_failure_strain(d_values, triaxiality, strain_rate, & + epsdot0, temp, troom, tmelt, failure_strain, ierr) + real(rk), intent(in) :: d_values(5) + real(rk), intent(in) :: triaxiality + real(rk), intent(in) :: strain_rate + real(rk), intent(in) :: epsdot0 + real(rk), intent(in) :: temp + real(rk), intent(in) :: troom + real(rk), intent(in) :: tmelt + real(rk), intent(out) :: failure_strain + integer, intent(out) :: ierr + real(rk) :: base + real(rk) :: rate_factor + real(rk) :: tstar + + ierr = SPH_SUCCESS + failure_strain = 0.0_rk + if (epsdot0 <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid failure strain rate reference is invalid') + ierr = SPH_ERROR_ARGUMENT + return + end if + base = d_values(1) + d_values(2) * exp(d_values(3) * triaxiality) + rate_factor = 1.0_rk + d_values(4) * log(max(strain_rate / epsdot0, 1.0_rk)) + call sph_solid_jc_temperature_star(temp, troom, tmelt, tstar, ierr) + if (ierr /= SPH_SUCCESS) return + failure_strain = base * rate_factor * (1.0_rk + d_values(5) * tstar) + if (failure_strain <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid Johnson-Cook failure strain is invalid') + ierr = SPH_ERROR_ARGUMENT + end if + end subroutine sph_solid_jc_failure_strain + + subroutine sph_solid_damage_update(damage_old, plastic_delta, failure_strain, & + damage_new, failure_status, ierr) + real(rk), intent(in) :: damage_old + real(rk), intent(in) :: plastic_delta + real(rk), intent(in) :: failure_strain + real(rk), intent(out) :: damage_new + integer, intent(out) :: failure_status + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + damage_new = damage_old + call sph_solid_clamp_unit(damage_new) + failure_status = SPH_STATUS_ACTIVE + if (failure_strain <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid damage update requires positive failure strain') + ierr = SPH_ERROR_ARGUMENT + return + end if + if (plastic_delta > 0.0_rk) damage_new = damage_new + plastic_delta / failure_strain + call sph_solid_clamp_unit(damage_new) + if (damage_new >= 1.0_rk) failure_status = SPH_STATUS_FAILED + end subroutine sph_solid_damage_update + + subroutine sph_solid_linear_softening(damage_value, width_value, softening, ierr) + real(rk), intent(in) :: damage_value + real(rk), intent(in) :: width_value + real(rk), intent(out) :: softening + integer, intent(out) :: ierr + real(rk) :: damage_limited + + ierr = SPH_SUCCESS + softening = 1.0_rk + if (width_value <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid softening width must be positive') + ierr = SPH_ERROR_ARGUMENT + return + end if + damage_limited = damage_value + call sph_solid_clamp_unit(damage_limited) + softening = 1.0_rk - damage_limited + call sph_solid_clamp_unit(softening) + end subroutine sph_solid_linear_softening + + subroutine sph_solid_scale_deviatoric(stress_in, scale, stress_out) + real(rk), intent(in) :: stress_in(6) + real(rk), intent(in) :: scale + real(rk), intent(out) :: stress_out(6) + real(rk) :: mean_stress + + mean_stress = sph_solid_mean_stress(stress_in) + stress_out = stress_in + stress_out(1) = mean_stress + scale * (stress_in(1) - mean_stress) + stress_out(2) = mean_stress + scale * (stress_in(2) - mean_stress) + stress_out(3) = mean_stress + scale * (stress_in(3) - mean_stress) + stress_out(4) = scale * stress_in(4) + stress_out(5) = scale * stress_in(5) + stress_out(6) = scale * stress_in(6) + end subroutine sph_solid_scale_deviatoric + + real(rk) function sph_solid_voigt_dot(left, right) + real(rk), intent(in) :: left(6) + real(rk), intent(in) :: right(6) + + sph_solid_voigt_dot = left(1) * right(1) + left(2) * right(2) + & + left(3) * right(3) + 2.0_rk * (left(4) * right(4) + & + left(5) * right(5) + left(6) * right(6)) + end function sph_solid_voigt_dot + + subroutine sph_solid_clamp_unit(value) + real(rk), intent(inout) :: value + + if (value < 0.0_rk) value = 0.0_rk + if (value > 1.0_rk) value = 1.0_rk + end subroutine sph_solid_clamp_unit + +end module sph_solid_material diff --git a/tests/module/test_solid_elastic_material.f90 b/tests/module/test_solid_elastic_material.f90 new file mode 100644 index 0000000..c9468f1 --- /dev/null +++ b/tests/module/test_solid_elastic_material.f90 @@ -0,0 +1,80 @@ +program test_solid_elastic_material + use sph_precision, only: rk + use sph_error, only: SPH_SUCCESS + use sph_api, only: sph_initialize, sph_finalize, sph_read_inp, sph_build_model + use sph_solid, only: sph_solid_update_particle_material + use sph_solid_state, only: solid_stress, solid_plastic_strain, solid_internal_energy + use sph_solid_material, only: sph_solid_elastic_constants, & + sph_solid_elastic_trial, sph_solid_von_mises, & + sph_solid_internal_energy_increment + implicit none + + integer :: ierr + + call check_elastic_helpers() + call check_elastic_particle_update() + +contains + + subroutine check_elastic_helpers() + real(rk) :: shear + real(rk) :: bulk + real(rk) :: wave_speed + real(rk) :: stress_old(6) + real(rk) :: stress_new(6) + real(rk) :: strain_inc(6) + real(rk) :: energy_inc + + call sph_solid_elastic_constants(210.0e9_rk, 0.30_rk, 7850.0_rk, & + shear, bulk, wave_speed, ierr) + call assert_ok(ierr, 'elastic constants failed') + if (shear <= 0.0_rk .or. bulk <= 0.0_rk) call fail('elastic constants missing') + if (wave_speed <= 0.0_rk) call fail('elastic wave speed missing') + stress_old = 0.0_rk + strain_inc = 0.0_rk + strain_inc(1) = 1.0e-5_rk + call sph_solid_elastic_trial(stress_old, strain_inc, shear, bulk, stress_new, ierr) + call assert_ok(ierr, 'elastic trial failed') + if (stress_new(1) <= 0.0_rk) call fail('elastic stress update missing') + if (sph_solid_von_mises(stress_new) <= 0.0_rk) call fail('von Mises stress missing') + call sph_solid_internal_energy_increment(stress_old, stress_new, strain_inc, & + 7850.0_rk, energy_inc, ierr) + call assert_ok(ierr, 'elastic energy increment failed') + if (energy_inc <= 0.0_rk) call fail('elastic internal energy increment missing') + end subroutine check_elastic_helpers + + subroutine check_elastic_particle_update() + real(rk) :: strain_inc(6) + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for elastic particle update') + call sph_read_inp('tests/data/solid_elastic_minimal_050.inp', ierr) + call assert_ok(ierr, 'read failed for elastic particle update') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for elastic particle update') + strain_inc = 0.0_rk + strain_inc(1) = 1.0e-5_rk + call sph_solid_update_particle_material(1, strain_inc, 1.0e-7_rk, ierr) + call assert_ok(ierr, 'elastic particle update failed') + if (solid_stress(1,1) <= 0.0_rk) call fail('particle elastic stress missing') + if (abs(solid_plastic_strain(1)) > 0.0_rk) call fail('elastic particle became plastic') + if (solid_internal_energy(1) <= 0.0_rk) call fail('particle elastic energy missing') + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for elastic particle update') + end subroutine check_elastic_particle_update + + subroutine assert_ok(ierr_value, message) + integer, intent(in) :: ierr_value + character(len=*), intent(in) :: message + + if (ierr_value /= SPH_SUCCESS) call fail(message) + end subroutine assert_ok + + subroutine fail(message) + character(len=*), intent(in) :: message + + write(*, '(A)') trim(message) + stop 1 + end subroutine fail + +end program test_solid_elastic_material diff --git a/tests/module/test_solid_johnson_cook_failure.f90 b/tests/module/test_solid_johnson_cook_failure.f90 new file mode 100644 index 0000000..bf747e1 --- /dev/null +++ b/tests/module/test_solid_johnson_cook_failure.f90 @@ -0,0 +1,79 @@ +program test_solid_johnson_cook_failure + use sph_precision, only: rk + use sph_error, only: SPH_SUCCESS + use sph_api, only: sph_initialize, sph_finalize, sph_read_inp, sph_build_model + use sph_database, only: particle_phase, particle_status, mass, & + SPH_PHASE_SOLID_FAILED, SPH_STATUS_FAILED + use sph_solid, only: sph_solid_mark_particle_failed + use sph_solid_state, only: solid_damage, solid_softening, solid_failure_status + use sph_solid_material, only: sph_solid_jc_failure_strain, sph_solid_damage_update + implicit none + + integer :: ierr + + call check_failure_helpers() + call check_failure_status_keeps_particle_mass() + +contains + + subroutine check_failure_helpers() + real(rk) :: d_values(5) + real(rk) :: failure_strain + real(rk) :: damage_new + integer :: failure_status + + d_values = (/ 0.05_rk, 3.44_rk, -2.12_rk, 0.002_rk, 0.61_rk /) + call sph_solid_jc_failure_strain(d_values, 0.0_rk, 1.0_rk, 1.0_rk, & + 293.0_rk, 293.0_rk, 1793.0_rk, failure_strain, ierr) + call assert_ok(ierr, 'Johnson-Cook failure strain failed') + if (failure_strain <= 0.0_rk) call fail('failure strain missing') + call sph_solid_damage_update(0.25_rk, 0.25_rk * failure_strain, & + failure_strain, damage_new, failure_status, ierr) + call assert_ok(ierr, 'damage update failed') + if (damage_new <= 0.25_rk) call fail('damage did not accumulate') + call sph_solid_damage_update(0.95_rk, 0.20_rk * failure_strain, & + failure_strain, damage_new, failure_status, ierr) + call assert_ok(ierr, 'failure damage update failed') + if (failure_status /= SPH_STATUS_FAILED) call fail('failure status was not set') + call sph_solid_damage_update(0.0_rk, 1.0_rk, 0.0_rk, damage_new, & + failure_status, ierr) + if (ierr == SPH_SUCCESS) call fail('invalid failure strain was accepted') + end subroutine check_failure_helpers + + subroutine check_failure_status_keeps_particle_mass() + real(rk) :: mass_before + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for failure status check') + call sph_read_inp('tests/data/solid_johnson_cook_failure_050.inp', ierr) + call assert_ok(ierr, 'read failed for failure status check') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for failure status check') + mass_before = mass(1) + call sph_solid_mark_particle_failed(1, ierr) + call assert_ok(ierr, 'mark failed particle failed') + if (solid_failure_status(1) /= SPH_STATUS_FAILED) call fail('Solid failure status mismatch') + if (particle_status(1) /= SPH_STATUS_FAILED) call fail('particle status mismatch after failure') + if (particle_phase(1) /= SPH_PHASE_SOLID_FAILED) call fail('particle phase mismatch after failure') + if (abs(mass(1) - mass_before) > 0.0_rk) call fail('failure changed particle mass') + if (solid_damage(1) < 1.0_rk) call fail('failure did not clamp damage') + if (abs(solid_softening(1)) > 0.0_rk) call fail('failure did not remove softening') + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for failure status check') + end subroutine check_failure_status_keeps_particle_mass + + subroutine assert_ok(ierr_value, message) + integer, intent(in) :: ierr_value + character(len=*), intent(in) :: message + + if (ierr_value /= SPH_SUCCESS) call fail(message) + end subroutine assert_ok + + subroutine fail(message) + character(len=*), intent(in) :: message + + write(*, '(A)') trim(message) + stop 1 + end subroutine fail + +end program test_solid_johnson_cook_failure diff --git a/tests/module/test_solid_johnson_cook_flow.f90 b/tests/module/test_solid_johnson_cook_flow.f90 new file mode 100644 index 0000000..dec2f93 --- /dev/null +++ b/tests/module/test_solid_johnson_cook_flow.f90 @@ -0,0 +1,80 @@ +program test_solid_johnson_cook_flow + use sph_precision, only: rk + use sph_error, only: SPH_SUCCESS + use sph_api, only: sph_initialize, sph_finalize, sph_read_inp, sph_build_model + use sph_solid, only: sph_solid_update_particle_material + use sph_solid_state, only: solid_stress, solid_plastic_strain, & + solid_plastic_strain_rate, solid_temperature, solid_temperature_rise_factor + use sph_solid_material, only: sph_solid_jc_flow_stress, sph_solid_von_mises + implicit none + + integer :: ierr + + call check_johnson_cook_flow_helpers() + call check_johnson_cook_particle_update() + +contains + + subroutine check_johnson_cook_flow_helpers() + real(rk) :: flow_static + real(rk) :: flow_hardened + + call sph_solid_jc_flow_stress(792.0e6_rk, 510.0e6_rk, 0.26_rk, & + 0.014_rk, 1.03_rk, 1.0_rk, 293.0_rk, 1793.0_rk, & + 0.0_rk, 0.0_rk, 293.0_rk, flow_static, ierr) + call assert_ok(ierr, 'Johnson-Cook static flow failed') + call sph_solid_jc_flow_stress(792.0e6_rk, 510.0e6_rk, 0.26_rk, & + 0.014_rk, 1.03_rk, 1.0_rk, 293.0_rk, 1793.0_rk, & + 0.10_rk, 100.0_rk, 293.0_rk, flow_hardened, ierr) + call assert_ok(ierr, 'Johnson-Cook hardened flow failed') + if (flow_static <= 0.0_rk) call fail('Johnson-Cook static flow missing') + if (flow_hardened <= flow_static) call fail('Johnson-Cook hardening/rate term missing') + call sph_solid_jc_flow_stress(792.0e6_rk, 510.0e6_rk, 0.26_rk, & + 0.014_rk, 1.03_rk, 0.0_rk, 293.0_rk, 1793.0_rk, & + 0.0_rk, 1.0_rk, 293.0_rk, flow_static, ierr) + if (ierr == SPH_SUCCESS) call fail('invalid Johnson-Cook epsdot0 was accepted') + call sph_solid_jc_flow_stress(792.0e6_rk, 510.0e6_rk, 0.26_rk, & + 0.014_rk, 1.03_rk, 1.0_rk, 293.0_rk, 293.0_rk, & + 0.0_rk, 1.0_rk, 293.0_rk, flow_static, ierr) + if (ierr == SPH_SUCCESS) call fail('invalid Johnson-Cook temperature range was accepted') + end subroutine check_johnson_cook_flow_helpers + + subroutine check_johnson_cook_particle_update() + real(rk) :: strain_inc(6) + real(rk) :: temp_before + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for Johnson-Cook update') + call sph_read_inp('tests/data/solid_johnson_cook_failure_050.inp', ierr) + call assert_ok(ierr, 'read failed for Johnson-Cook update') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for Johnson-Cook update') + solid_temperature_rise_factor(1) = 1.0e-6_rk + temp_before = solid_temperature(1) + strain_inc = 0.0_rk + strain_inc(4) = 2.0e-2_rk + call sph_solid_update_particle_material(1, strain_inc, 1.0e-6_rk, ierr) + call assert_ok(ierr, 'Johnson-Cook particle update failed') + if (solid_plastic_strain(1) <= 0.0_rk) call fail('plastic strain was not updated') + if (solid_plastic_strain_rate(1) <= 0.0_rk) call fail('plastic strain rate was not updated') + if (sph_solid_von_mises(solid_stress(:,1)) <= 0.0_rk) call fail('plastic stress missing') + if (solid_temperature(1) <= temp_before) call fail('plastic temperature did not increase') + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for Johnson-Cook update') + end subroutine check_johnson_cook_particle_update + + subroutine assert_ok(ierr_value, message) + integer, intent(in) :: ierr_value + character(len=*), intent(in) :: message + + if (ierr_value /= SPH_SUCCESS) call fail(message) + end subroutine assert_ok + + subroutine fail(message) + character(len=*), intent(in) :: message + + write(*, '(A)') trim(message) + stop 1 + end subroutine fail + +end program test_solid_johnson_cook_flow diff --git a/tests/module/test_solid_progressive_softening.f90 b/tests/module/test_solid_progressive_softening.f90 new file mode 100644 index 0000000..f358bd8 --- /dev/null +++ b/tests/module/test_solid_progressive_softening.f90 @@ -0,0 +1,46 @@ +program test_solid_progressive_softening + use sph_precision, only: rk + use sph_error, only: SPH_SUCCESS + use sph_solid_material, only: sph_solid_linear_softening + implicit none + + integer :: ierr + + call check_linear_softening() + +contains + + subroutine check_linear_softening() + real(rk) :: softening + + call sph_solid_linear_softening(0.0_rk, 1.0_rk, softening, ierr) + call assert_ok(ierr, 'zero damage softening failed') + if (abs(softening - 1.0_rk) > 1.0e-12_rk) call fail('zero damage softening mismatch') + call sph_solid_linear_softening(0.40_rk, 1.0_rk, softening, ierr) + call assert_ok(ierr, 'partial damage softening failed') + if (abs(softening - 0.60_rk) > 1.0e-12_rk) call fail('partial damage softening mismatch') + call sph_solid_linear_softening(2.0_rk, 1.0_rk, softening, ierr) + call assert_ok(ierr, 'clamped damage softening failed') + if (abs(softening) > 0.0_rk) call fail('over-damage softening was not clamped') + call sph_solid_linear_softening(-1.0_rk, 1.0_rk, softening, ierr) + call assert_ok(ierr, 'negative damage softening failed') + if (abs(softening - 1.0_rk) > 1.0e-12_rk) call fail('negative damage softening mismatch') + call sph_solid_linear_softening(0.5_rk, 0.0_rk, softening, ierr) + if (ierr == SPH_SUCCESS) call fail('invalid softening width was accepted') + end subroutine check_linear_softening + + subroutine assert_ok(ierr_value, message) + integer, intent(in) :: ierr_value + character(len=*), intent(in) :: message + + if (ierr_value /= SPH_SUCCESS) call fail(message) + end subroutine assert_ok + + subroutine fail(message) + character(len=*), intent(in) :: message + + write(*, '(A)') trim(message) + stop 1 + end subroutine fail + +end program test_solid_progressive_softening diff --git a/todo.md b/todo.md index 3d14764..54cf162 100644 --- a/todo.md +++ b/todo.md @@ -88,34 +88,34 @@ ## 阶段 D:弹性、Johnson-Cook 本构与失效材料点 -- [ ] 新增 Solid 弹性常数计算 helper。 -- [ ] 新增 Voigt 应力应变工具函数。 -- [ ] 新增 von Mises 等效应力计算。 -- [ ] 新增等效塑性应变率安全计算。 -- [ ] 实现弹性材料点试应力更新。 -- [ ] 实现弹性材料点内能更新。 -- [ ] 新增弹性区材料点单测。 -- [ ] 实现 Johnson-Cook 热软化温度归一化。 -- [ ] 实现 Johnson-Cook 应变率项计算。 -- [ ] 实现 Johnson-Cook 硬化项计算。 -- [ ] 实现 Johnson-Cook 流动应力计算。 -- [ ] 对非正参考应变率或非法温度参数报 error。 -- [ ] 实现塑性屈服判断。 -- [ ] 实现简化显式返回映射或等价塑性修正。 -- [ ] 更新等效塑性应变和等效塑性应变率。 -- [ ] 更新塑性功和等效温升状态。 -- [ ] 新增 Johnson-Cook flow 单测。 -- [ ] 实现 Johnson-Cook failure 应变计算。 -- [ ] 实现 Johnson-Cook damage 单调累积。 -- [ ] 对非法 failure 应变进行受控 error 或保护。 -- [ ] 实现 damage 达到阈值后的失效状态切换。 -- [ ] 实现线性渐进软化因子更新。 -- [ ] 限制 damage 和 softening 在合法范围。 -- [ ] 确认失效后不删除粒子、不改变质量。 -- [ ] 新增 `solid_elastic_material` 测试并接入 CTest。 -- [ ] 新增 `solid_johnson_cook_flow` 测试并接入 CTest。 -- [ ] 新增 `solid_johnson_cook_failure` 测试并接入 CTest。 -- [ ] 新增 `solid_progressive_softening` 测试并接入 CTest。 +- [x] 新增 Solid 弹性常数计算 helper。 +- [x] 新增 Voigt 应力应变工具函数。 +- [x] 新增 von Mises 等效应力计算。 +- [x] 新增等效塑性应变率安全计算。 +- [x] 实现弹性材料点试应力更新。 +- [x] 实现弹性材料点内能更新。 +- [x] 新增弹性区材料点单测。 +- [x] 实现 Johnson-Cook 热软化温度归一化。 +- [x] 实现 Johnson-Cook 应变率项计算。 +- [x] 实现 Johnson-Cook 硬化项计算。 +- [x] 实现 Johnson-Cook 流动应力计算。 +- [x] 对非正参考应变率或非法温度参数报 error。 +- [x] 实现塑性屈服判断。 +- [x] 实现简化显式返回映射或等价塑性修正。 +- [x] 更新等效塑性应变和等效塑性应变率。 +- [x] 更新塑性功和等效温升状态。 +- [x] 新增 Johnson-Cook flow 单测。 +- [x] 实现 Johnson-Cook failure 应变计算。 +- [x] 实现 Johnson-Cook damage 单调累积。 +- [x] 对非法 failure 应变进行受控 error 或保护。 +- [x] 实现 damage 达到阈值后的失效状态切换。 +- [x] 实现线性渐进软化因子更新。 +- [x] 限制 damage 和 softening 在合法范围。 +- [x] 确认失效后不删除粒子、不改变质量。 +- [x] 新增 `solid_elastic_material` 测试并接入 CTest。 +- [x] 新增 `solid_johnson_cook_flow` 测试并接入 CTest。 +- [x] 新增 `solid_johnson_cook_failure` 测试并接入 CTest。 +- [x] 新增 `solid_progressive_softening` 测试并接入 CTest。 ## 阶段 E:Solid SPH 结构状态、显式推进与稳定时间步