From 69249f1e827c9e842d162ef1b1e82c42a6a9a1bc Mon Sep 17 00:00:00 2001 From: Codex Date: Fri, 3 Jul 2026 17:29:47 +0800 Subject: [PATCH] Add Solid kinematic strain update --- CMakeLists.txt | 12 ++ src/solid/sph_solid.f90 | 8 ++ src/solid/sph_solid_dynamics.f90 | 91 ++++++++++++ src/solid/sph_solid_state.f90 | 3 + tests/module/test_solid_strain_increment.f90 | 134 +++++++++++++++++ tests/module/test_solid_velocity_gradient.f90 | 136 ++++++++++++++++++ todo.md | 56 ++++---- 7 files changed, 412 insertions(+), 28 deletions(-) create mode 100644 tests/module/test_solid_strain_increment.f90 create mode 100644 tests/module/test_solid_velocity_gradient.f90 diff --git a/CMakeLists.txt b/CMakeLists.txt index ccbe40a..335c1ce 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -235,6 +235,18 @@ set_target_properties(test_solid_correction_matrix PROPERTIES Fortran_MODULE_DIR add_test(NAME solid_correction_matrix COMMAND test_solid_correction_matrix) set_tests_properties(solid_correction_matrix PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_executable(test_solid_velocity_gradient tests/module/test_solid_velocity_gradient.f90) +target_link_libraries(test_solid_velocity_gradient PRIVATE sphlite_core) +set_target_properties(test_solid_velocity_gradient PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME solid_velocity_gradient COMMAND test_solid_velocity_gradient) +set_tests_properties(solid_velocity_gradient PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + +add_executable(test_solid_strain_increment tests/module/test_solid_strain_increment.f90) +target_link_libraries(test_solid_strain_increment PRIVATE sphlite_core) +set_target_properties(test_solid_strain_increment PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME solid_strain_increment COMMAND test_solid_strain_increment) +set_tests_properties(solid_strain_increment PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_executable(test_solid_stable_dt tests/module/test_solid_stable_dt.f90) target_link_libraries(test_solid_stable_dt PRIVATE sphlite_core) set_target_properties(test_solid_stable_dt PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") diff --git a/src/solid/sph_solid.f90 b/src/solid/sph_solid.f90 index 5c66d6c..4fb3d44 100644 --- a/src/solid/sph_solid.f90 +++ b/src/solid/sph_solid.f90 @@ -378,6 +378,8 @@ contains solid_deformation_gradient(SPH_NDIM,SPH_NDIM,npart), & solid_correction_matrix(SPH_NDIM,SPH_NDIM,npart), & solid_correction_determinant(npart), & + solid_velocity_gradient(SPH_NDIM,SPH_NDIM,npart), & + solid_strain_rate(6,npart), solid_strain_rate_eq(npart), & solid_acc_internal(SPH_NDIM,npart), & solid_reference_neighbor_count(npart), & solid_reference_degenerate(npart), solid_correction_status(npart), & @@ -404,6 +406,9 @@ contains if (allocated(solid_deformation_gradient)) deallocate(solid_deformation_gradient) if (allocated(solid_correction_matrix)) deallocate(solid_correction_matrix) if (allocated(solid_correction_determinant)) deallocate(solid_correction_determinant) + if (allocated(solid_velocity_gradient)) deallocate(solid_velocity_gradient) + if (allocated(solid_strain_rate)) deallocate(solid_strain_rate) + if (allocated(solid_strain_rate_eq)) deallocate(solid_strain_rate_eq) if (allocated(solid_acc_internal)) deallocate(solid_acc_internal) if (allocated(solid_reference_neighbor_count)) deallocate(solid_reference_neighbor_count) if (allocated(solid_reference_degenerate)) deallocate(solid_reference_degenerate) @@ -424,6 +429,9 @@ contains if (allocated(solid_deformation_gradient)) solid_deformation_gradient = 0.0_rk if (allocated(solid_correction_matrix)) solid_correction_matrix = 0.0_rk if (allocated(solid_correction_determinant)) solid_correction_determinant = 0.0_rk + if (allocated(solid_velocity_gradient)) solid_velocity_gradient = 0.0_rk + if (allocated(solid_strain_rate)) solid_strain_rate = 0.0_rk + if (allocated(solid_strain_rate_eq)) solid_strain_rate_eq = 0.0_rk if (allocated(solid_acc_internal)) solid_acc_internal = 0.0_rk if (allocated(solid_reference_neighbor_count)) solid_reference_neighbor_count = 0 if (allocated(solid_reference_degenerate)) solid_reference_degenerate = 0 diff --git a/src/solid/sph_solid_dynamics.f90 b/src/solid/sph_solid_dynamics.f90 index a48d827..12d7d54 100644 --- a/src/solid/sph_solid_dynamics.f90 +++ b/src/solid/sph_solid_dynamics.f90 @@ -260,6 +260,73 @@ contains end do end subroutine sph_solid_set_identity + subroutine sph_solid_compute_velocity_gradient(ierr) + integer, intent(out) :: ierr + integer :: i + integer :: j + integer :: row + integer :: col + real(rk) :: rij(SPH_NDIM) + real(rk) :: dv(SPH_NDIM) + real(rk) :: distance + real(rk) :: radius + real(rk) :: weight + real(rk) :: moment(SPH_NDIM,SPH_NDIM) + + ierr = SPH_SUCCESS + if (.not. allocated(solid_velocity_gradient)) return + solid_velocity_gradient = 0.0_rk + solid_strain_rate = 0.0_rk + solid_strain_rate_eq = 0.0_rk + do i = 1, npart + if (.not. sph_solid_is_active(i)) cycle + if (.not. allocated(solid_correction_status)) cycle + if (solid_correction_status(i) /= SPH_SOLID_CORRECTION_OK) cycle + moment = 0.0_rk + do j = 1, npart + if (j == i) cycle + if (.not. sph_solid_is_active(j)) cycle + radius = 2.0_rk * max(h(i), h(j)) + rij = x0(:,j) - x0(:,i) + distance = sqrt(sum(rij * rij)) + if (distance <= 0.0_rk .or. distance > radius) cycle + dv = v(:,j) - v(:,i) + weight = solid_reference_volume(j) + do row = 1, SPH_NDIM + do col = 1, SPH_NDIM + moment(row,col) = moment(row,col) + weight * dv(row) * rij(col) + end do + end do + end do + solid_velocity_gradient(:,:,i) = matmul(moment, solid_correction_matrix(:,:,i)) + call sph_solid_store_strain_rate(i) + end do + end subroutine sph_solid_compute_velocity_gradient + + subroutine sph_solid_store_strain_rate(index) + integer, intent(in) :: index + real(rk) :: grad(SPH_NDIM,SPH_NDIM) + real(rk) :: trace_rate + real(rk) :: dev(3) + real(rk) :: norm2 + + grad = solid_velocity_gradient(:,:,index) + solid_strain_rate(1,index) = grad(1,1) + solid_strain_rate(2,index) = grad(2,2) + solid_strain_rate(3,index) = grad(3,3) + solid_strain_rate(4,index) = 0.5_rk * (grad(1,2) + grad(2,1)) + solid_strain_rate(5,index) = 0.5_rk * (grad(2,3) + grad(3,2)) + solid_strain_rate(6,index) = 0.5_rk * (grad(1,3) + grad(3,1)) + trace_rate = (solid_strain_rate(1,index) + solid_strain_rate(2,index) + & + solid_strain_rate(3,index)) / 3.0_rk + dev(1) = solid_strain_rate(1,index) - trace_rate + dev(2) = solid_strain_rate(2,index) - trace_rate + dev(3) = solid_strain_rate(3,index) - trace_rate + norm2 = sum(dev * dev) + 2.0_rk * (solid_strain_rate(4,index)**2 + & + solid_strain_rate(5,index)**2 + solid_strain_rate(6,index)**2) + solid_strain_rate_eq(index) = sqrt(max(0.0_rk, 2.0_rk * norm2 / 3.0_rk)) + end subroutine sph_solid_store_strain_rate + subroutine sph_solid_compute_particle_strain_increment(index, dt, strain_inc, ierr) integer, intent(in) :: index real(rk), intent(in) :: dt @@ -276,7 +343,11 @@ contains if (dt <= 0.0_rk) then call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid strain update requires positive dt') ierr = SPH_ERROR_ARGUMENT + return end if + if (.not. allocated(solid_strain_rate)) return + if (.not. sph_solid_is_active(index)) return + strain_inc = dt * solid_strain_rate(:,index) end subroutine sph_solid_compute_particle_strain_increment subroutine sph_solid_compute_internal_acceleration(ierr) @@ -308,15 +379,35 @@ contains ierr = SPH_SUCCESS if (.not. allocated(solid_stress)) return + call sph_solid_compute_velocity_gradient(ierr) + if (ierr /= SPH_SUCCESS) return do i = 1, npart if (.not. sph_solid_is_active(i)) cycle call sph_solid_compute_particle_strain_increment(i, dt, strain_inc, ierr) if (ierr /= SPH_SUCCESS) return + call sph_solid_update_deformation_gradient(i, dt, ierr) + if (ierr /= SPH_SUCCESS) return call sph_solid_update_particle_material(i, strain_inc, dt, ierr) if (ierr /= SPH_SUCCESS) return end do end subroutine sph_solid_advance_material + subroutine sph_solid_update_deformation_gradient(index, dt, ierr) + integer, intent(in) :: index + real(rk), intent(in) :: dt + integer, intent(out) :: ierr + real(rk) :: increment(SPH_NDIM,SPH_NDIM) + + ierr = SPH_SUCCESS + if (.not. allocated(solid_deformation_gradient)) return + if (.not. allocated(solid_velocity_gradient)) return + if (.not. sph_solid_is_active(index)) return + call sph_solid_set_identity(increment) + increment = increment + dt * solid_velocity_gradient(:,:,index) + solid_deformation_gradient(:,:,index) = & + matmul(increment, solid_deformation_gradient(:,:,index)) + end subroutine sph_solid_update_deformation_gradient + subroutine sph_solid_update_diagnostics(ierr) integer, intent(out) :: ierr integer :: i diff --git a/src/solid/sph_solid_state.f90 b/src/solid/sph_solid_state.f90 index 2b97218..bae9495 100644 --- a/src/solid/sph_solid_state.f90 +++ b/src/solid/sph_solid_state.f90 @@ -22,6 +22,9 @@ module sph_solid_state real(rk), allocatable :: solid_deformation_gradient(:,:,:) real(rk), allocatable :: solid_correction_matrix(:,:,:) real(rk), allocatable :: solid_correction_determinant(:) + real(rk), allocatable :: solid_velocity_gradient(:,:,:) + real(rk), allocatable :: solid_strain_rate(:,:) + real(rk), allocatable :: solid_strain_rate_eq(:) real(rk), allocatable :: solid_acc_internal(:,:) integer, allocatable :: solid_reference_neighbor_count(:) integer, allocatable :: solid_reference_degenerate(:) diff --git a/tests/module/test_solid_strain_increment.f90 b/tests/module/test_solid_strain_increment.f90 new file mode 100644 index 0000000..13f7d77 --- /dev/null +++ b/tests/module/test_solid_strain_increment.f90 @@ -0,0 +1,134 @@ +program test_solid_strain_increment + 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: npart, x0, v, particle_phase, & + SPH_PHASE_SOLID_FAILED + use sph_solid, only: sph_solid_mark_particle_failed + use sph_solid_dynamics, only: sph_solid_advance_material + use sph_solid_state, only: solid_strain, solid_stress, & + solid_plastic_strain_rate, solid_temperature, solid_damage, & + solid_softening, solid_temperature_rise_factor, & + solid_deformation_gradient + implicit none + + integer :: ierr + + call check_elastic_strain_increment() + call check_johnson_cook_kinematic_update() + call check_failed_phase_is_irreversible() + +contains + + subroutine check_elastic_strain_increment() + integer :: i + real(rk) :: alpha + real(rk) :: dt + + alpha = 5.0_rk + dt = 2.0e-7_rk + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for elastic strain increment') + call sph_read_inp('tests/data/solid_uniaxial_velocity_051.inp', ierr) + call assert_ok(ierr, 'read failed for elastic strain increment') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for elastic strain increment') + do i = 1, npart + v(:,i) = 0.0_rk + v(1,i) = alpha * x0(1,i) + end do + call sph_solid_advance_material(dt, ierr) + call assert_ok(ierr, 'elastic kinematic material advance failed') + do i = 1, npart + call assert_close(solid_strain(1,i), alpha * dt, & + 'elastic strain increment mismatch') + call assert_close(solid_deformation_gradient(1,1,i), 1.0_rk + alpha * dt, & + 'elastic deformation gradient mismatch') + if (abs(solid_plastic_strain_rate(i)) > 0.0_rk) then + call fail('elastic plastic strain-rate default mismatch') + end if + if (solid_stress(1,i) <= 0.0_rk) call fail('elastic stress was not updated') + end do + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for elastic strain increment') + end subroutine check_elastic_strain_increment + + subroutine check_johnson_cook_kinematic_update() + integer :: i + real(rk) :: alpha + real(rk) :: dt + real(rk) :: damage_before + real(rk) :: softening_before + real(rk) :: temperature_before + + alpha = 1.0e7_rk + dt = 1.0e-7_rk + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for Johnson-Cook kinematic update') + call sph_read_inp('tests/data/solid_johnson_cook_failure_050.inp', ierr) + call assert_ok(ierr, 'read failed for Johnson-Cook kinematic update') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for Johnson-Cook kinematic update') + solid_temperature_rise_factor(1) = 0.0_rk + damage_before = solid_damage(1) + softening_before = solid_softening(1) + temperature_before = solid_temperature(1) + do i = 1, npart + v(:,i) = 0.0_rk + v(1,i) = alpha * x0(1,i) + end do + call sph_solid_advance_material(dt, ierr) + call assert_ok(ierr, 'Johnson-Cook kinematic material advance failed') + if (solid_damage(1) < damage_before) call fail('damage decreased') + if (solid_softening(1) > softening_before) call fail('softening increased') + if (abs(solid_temperature(1) - temperature_before) > 1.0e-12_rk) then + call fail('isothermal Johnson-Cook temperature changed') + end if + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for Johnson-Cook kinematic update') + end subroutine check_johnson_cook_kinematic_update + + subroutine check_failed_phase_is_irreversible() + real(rk) :: dt + + dt = 1.0e-7_rk + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for failed phase check') + call sph_read_inp('tests/data/solid_uniaxial_velocity_051.inp', ierr) + call assert_ok(ierr, 'read failed for failed phase check') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for failed phase check') + call sph_solid_mark_particle_failed(1, ierr) + call assert_ok(ierr, 'failed phase mark failed') + call sph_solid_advance_material(dt, ierr) + call assert_ok(ierr, 'failed phase material advance failed') + if (particle_phase(1) /= SPH_PHASE_SOLID_FAILED) then + call fail('failed Solid phase was restored') + end if + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for failed phase check') + end subroutine check_failed_phase_is_irreversible + + subroutine assert_close(value, expected, message) + real(rk), intent(in) :: value + real(rk), intent(in) :: expected + character(len=*), intent(in) :: message + + if (abs(value - expected) > 1.0e-10_rk) call fail(message) + end subroutine assert_close + + 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_strain_increment diff --git a/tests/module/test_solid_velocity_gradient.f90 b/tests/module/test_solid_velocity_gradient.f90 new file mode 100644 index 0000000..582a292 --- /dev/null +++ b/tests/module/test_solid_velocity_gradient.f90 @@ -0,0 +1,136 @@ +program test_solid_velocity_gradient + use sph_precision, only: rk, SPH_NDIM + use sph_error, only: SPH_SUCCESS + use sph_api, only: sph_initialize, sph_finalize, sph_read_inp, sph_build_model + use sph_database, only: npart, x0, v + use sph_solid_dynamics, only: sph_solid_compute_velocity_gradient + use sph_solid_state, only: solid_velocity_gradient, solid_strain_rate, & + solid_strain_rate_eq + implicit none + + integer :: ierr + + call check_uniform_translation() + call check_uniaxial_velocity_field() + call check_non_solid_velocity_is_ignored() + +contains + + subroutine check_uniform_translation() + integer :: i + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for uniform translation') + call sph_read_inp('tests/data/solid_uniform_translation_051.inp', ierr) + call assert_ok(ierr, 'read failed for uniform translation') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for uniform translation') + do i = 1, npart + v(:,i) = (/ 1.0_rk, -2.0_rk, 3.0_rk /) + end do + call sph_solid_compute_velocity_gradient(ierr) + call assert_ok(ierr, 'velocity gradient failed for uniform translation') + if (maxval(abs(solid_velocity_gradient(:,:,1:npart))) > 1.0e-12_rk) then + call fail('uniform translation produced Solid velocity gradient') + end if + if (maxval(abs(solid_strain_rate(:,1:npart))) > 1.0e-12_rk) then + call fail('uniform translation produced Solid strain rate') + end if + if (maxval(abs(solid_strain_rate_eq(1:npart))) > 1.0e-12_rk) then + call fail('uniform translation produced equivalent strain rate') + end if + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for uniform translation') + end subroutine check_uniform_translation + + subroutine check_uniaxial_velocity_field() + integer :: i + real(rk) :: alpha + real(rk) :: expected_eq + + alpha = 4.0_rk + expected_eq = 2.0_rk * alpha / 3.0_rk + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for uniaxial velocity') + call sph_read_inp('tests/data/solid_uniaxial_velocity_051.inp', ierr) + call assert_ok(ierr, 'read failed for uniaxial velocity') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for uniaxial velocity') + do i = 1, npart + v(:,i) = 0.0_rk + v(1,i) = alpha * x0(1,i) + end do + call sph_solid_compute_velocity_gradient(ierr) + call assert_ok(ierr, 'velocity gradient failed for uniaxial velocity') + do i = 1, npart + call assert_close(solid_velocity_gradient(1,1,i), alpha, & + 'uniaxial dvx/dx mismatch') + call assert_close(solid_strain_rate(1,i), alpha, & + 'uniaxial strain-rate mismatch') + call assert_close(solid_strain_rate_eq(i), expected_eq, & + 'uniaxial equivalent strain-rate mismatch') + call assert_off_axis_zero(i) + end do + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for uniaxial velocity') + end subroutine check_uniaxial_velocity_field + + subroutine check_non_solid_velocity_is_ignored() + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for mixed velocity') + call sph_read_inp('tests/data/solid_state_mixed_050.inp', ierr) + call assert_ok(ierr, 'read failed for mixed velocity') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for mixed velocity') + v(:,1) = 0.0_rk + v(:,2) = (/ 100.0_rk, 0.0_rk, 0.0_rk /) + call sph_solid_compute_velocity_gradient(ierr) + call assert_ok(ierr, 'velocity gradient failed for mixed velocity') + if (maxval(abs(solid_velocity_gradient(:,:,1))) > 1.0e-12_rk) then + call fail('non-Solid velocity polluted Solid velocity gradient') + end if + if (maxval(abs(solid_velocity_gradient(:,:,2))) > 1.0e-12_rk) then + call fail('non-Solid velocity gradient state was not zero') + end if + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for mixed velocity') + end subroutine check_non_solid_velocity_is_ignored + + subroutine assert_off_axis_zero(index) + integer, intent(in) :: index + integer :: row + integer :: col + + do row = 1, SPH_NDIM + do col = 1, SPH_NDIM + if (row == 1 .and. col == 1) cycle + if (abs(solid_velocity_gradient(row,col,index)) > 1.0e-10_rk) then + call fail('uniaxial off-axis velocity gradient mismatch') + end if + end do + end do + end subroutine assert_off_axis_zero + + subroutine assert_close(value, expected, message) + real(rk), intent(in) :: value + real(rk), intent(in) :: expected + character(len=*), intent(in) :: message + + if (abs(value - expected) > 1.0e-10_rk) call fail(message) + end subroutine assert_close + + 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_velocity_gradient diff --git a/todo.md b/todo.md index 1d867f6..a68004d 100644 --- a/todo.md +++ b/todo.md @@ -89,34 +89,34 @@ ## 阶段 D:速度梯度、应变率和运动学驱动本构 -- [ ] 新增或补齐 Solid 速度梯度工作数组。 -- [ ] 新增或补齐 Solid 应变率状态数组。 -- [ ] 新增或补齐 Solid 等效应变率状态数组。 -- [ ] 在 Solid reset 路径初始化速度梯度和应变率状态。 -- [ ] 在 Solid allocate/build 路径分配速度梯度和应变率状态。 -- [ ] 在 Solid clear/finalize 路径释放速度梯度和应变率状态。 -- [ ] 实现 active Solid 粒子的速度梯度计算入口。 -- [ ] 确认无 active Solid 粒子时跳过速度梯度计算。 -- [ ] 确认非 Solid 粒子不污染 Solid 速度梯度。 -- [ ] 实现均匀平动下速度梯度为零的路径。 -- [ ] 实现单轴拉伸速度场下速度梯度计算。 -- [ ] 由速度梯度计算对称应变率。 -- [ ] 将应变率转换为 Voigt 顺序。 -- [ ] 由应变率和 dt 更新 Solid 应变增量。 -- [ ] 更新 Solid 总应变状态。 -- [ ] 由应变率计算等效塑性应变率的安全默认值。 -- [ ] 将变形梯度更新挂接到速度梯度路径。 -- [ ] 让弹性材料点更新接受运动学应变增量。 -- [ ] 让 Johnson-Cook flow 更新接受运动学应变增量。 -- [ ] 让 Johnson-Cook failure 更新接受运动学应变增量。 -- [ ] 保持等温退化测试下温度状态可恢复。 -- [ ] 确认 damage 单调不减。 -- [ ] 确认 softening 单调不增。 -- [ ] 确认 `PHASE_SOLID_FAILED` 不可逆。 -- [ ] 新增 `solid_velocity_gradient` 测试。 -- [ ] 新增 `solid_strain_increment` 测试。 -- [ ] 将 `solid_velocity_gradient` 接入 CTest。 -- [ ] 将 `solid_strain_increment` 接入 CTest。 +- [x] 新增或补齐 Solid 速度梯度工作数组。 +- [x] 新增或补齐 Solid 应变率状态数组。 +- [x] 新增或补齐 Solid 等效应变率状态数组。 +- [x] 在 Solid reset 路径初始化速度梯度和应变率状态。 +- [x] 在 Solid allocate/build 路径分配速度梯度和应变率状态。 +- [x] 在 Solid clear/finalize 路径释放速度梯度和应变率状态。 +- [x] 实现 active Solid 粒子的速度梯度计算入口。 +- [x] 确认无 active Solid 粒子时跳过速度梯度计算。 +- [x] 确认非 Solid 粒子不污染 Solid 速度梯度。 +- [x] 实现均匀平动下速度梯度为零的路径。 +- [x] 实现单轴拉伸速度场下速度梯度计算。 +- [x] 由速度梯度计算对称应变率。 +- [x] 将应变率转换为 Voigt 顺序。 +- [x] 由应变率和 dt 更新 Solid 应变增量。 +- [x] 更新 Solid 总应变状态。 +- [x] 由应变率计算等效塑性应变率的安全默认值。 +- [x] 将变形梯度更新挂接到速度梯度路径。 +- [x] 让弹性材料点更新接受运动学应变增量。 +- [x] 让 Johnson-Cook flow 更新接受运动学应变增量。 +- [x] 让 Johnson-Cook failure 更新接受运动学应变增量。 +- [x] 保持等温退化测试下温度状态可恢复。 +- [x] 确认 damage 单调不减。 +- [x] 确认 softening 单调不增。 +- [x] 确认 `PHASE_SOLID_FAILED` 不可逆。 +- [x] 新增 `solid_velocity_gradient` 测试。 +- [x] 新增 `solid_strain_increment` 测试。 +- [x] 将 `solid_velocity_gradient` 接入 CTest。 +- [x] 将 `solid_strain_increment` 接入 CTest。 ## 阶段 E:最小 Solid 内力、softening 作用与动力学诊断