From d3c3a3359a2d653c0aa30f84b5eddad1368846eb Mon Sep 17 00:00:00 2001 From: Codex Date: Fri, 3 Jul 2026 13:28:16 +0800 Subject: [PATCH] Add explosive release balance state --- CMakeLists.txt | 12 ++ src/explosive/sph_explosive.f90 | 76 +++++++++++- src/explosive/sph_explosive_state.f90 | 6 + .../test_explosive_initial_mass_release.f90 | 68 ++++++++++ .../module/test_explosive_release_balance.f90 | 117 ++++++++++++++++++ todo.md | 40 +++--- 6 files changed, 298 insertions(+), 21 deletions(-) create mode 100644 tests/module/test_explosive_initial_mass_release.f90 create mode 100644 tests/module/test_explosive_release_balance.f90 diff --git a/CMakeLists.txt b/CMakeLists.txt index 216ff7e..927f53e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -311,6 +311,18 @@ set_target_properties(test_explosive_reaction_progress PROPERTIES Fortran_MODULE add_test(NAME explosive_reaction_progress COMMAND test_explosive_reaction_progress) set_tests_properties(explosive_reaction_progress PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_executable(test_explosive_initial_mass_release tests/module/test_explosive_initial_mass_release.f90) +target_link_libraries(test_explosive_initial_mass_release PRIVATE sphlite_core) +set_target_properties(test_explosive_initial_mass_release PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME explosive_initial_mass_release COMMAND test_explosive_initial_mass_release) +set_tests_properties(explosive_initial_mass_release PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + +add_executable(test_explosive_release_balance tests/module/test_explosive_release_balance.f90) +target_link_libraries(test_explosive_release_balance PRIVATE sphlite_core) +set_target_properties(test_explosive_release_balance PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME explosive_release_balance COMMAND test_explosive_release_balance) +set_tests_properties(explosive_release_balance PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_executable(test_explosive_release_source tests/module/test_explosive_release_source.f90) target_link_libraries(test_explosive_release_source PRIVATE sphlite_core) set_target_properties(test_explosive_release_source PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") diff --git a/src/explosive/sph_explosive.f90 b/src/explosive/sph_explosive.f90 index 7d470c2..90ffb61 100644 --- a/src/explosive/sph_explosive.f90 +++ b/src/explosive/sph_explosive.f90 @@ -40,6 +40,9 @@ contains explosive_ignition_material_id = 0 explosive_ignition_x = 0.0_rk explosive_ignition_time = 0.0_rk + explosive_release_mass_balance = 0.0_rk + explosive_release_energy_balance = 0.0_rk + explosive_release_momentum_balance = 0.0_rk explosive_dt_reaction = 0.0_rk end subroutine sph_explosive_clear_material_table @@ -75,6 +78,9 @@ contains allocate(explosive_ignition_status(npart), & explosive_detonation_time(npart), & explosive_reaction_progress(npart), & + explosive_initial_material_id(npart), & + explosive_initial_mass(npart), & + explosive_remaining_mass(npart), & explosive_released_mass(npart), & explosive_released_energy(npart), & explosive_released_momentum(SPH_NDIM,npart), stat=stat) @@ -90,6 +96,9 @@ contains if (allocated(explosive_ignition_status)) deallocate(explosive_ignition_status) if (allocated(explosive_detonation_time)) deallocate(explosive_detonation_time) if (allocated(explosive_reaction_progress)) deallocate(explosive_reaction_progress) + if (allocated(explosive_initial_material_id)) deallocate(explosive_initial_material_id) + if (allocated(explosive_initial_mass)) deallocate(explosive_initial_mass) + if (allocated(explosive_remaining_mass)) deallocate(explosive_remaining_mass) if (allocated(explosive_released_mass)) deallocate(explosive_released_mass) if (allocated(explosive_released_energy)) deallocate(explosive_released_energy) if (allocated(explosive_released_momentum)) deallocate(explosive_released_momentum) @@ -99,9 +108,15 @@ contains if (allocated(explosive_ignition_status)) explosive_ignition_status = 0 if (allocated(explosive_detonation_time)) explosive_detonation_time = 0.0_rk if (allocated(explosive_reaction_progress)) explosive_reaction_progress = 0.0_rk + if (allocated(explosive_initial_material_id)) explosive_initial_material_id = 0 + if (allocated(explosive_initial_mass)) explosive_initial_mass = 0.0_rk + if (allocated(explosive_remaining_mass)) explosive_remaining_mass = 0.0_rk if (allocated(explosive_released_mass)) explosive_released_mass = 0.0_rk if (allocated(explosive_released_energy)) explosive_released_energy = 0.0_rk if (allocated(explosive_released_momentum)) explosive_released_momentum = 0.0_rk + explosive_release_mass_balance = 0.0_rk + explosive_release_energy_balance = 0.0_rk + explosive_release_momentum_balance = 0.0_rk end subroutine sph_explosive_clear_particle_state subroutine sph_explosive_note_material(name, material_type_in) @@ -346,7 +361,11 @@ contains rho(i) = material_density(mat_index) if (mass(i) <= 0.0_rk) mass(i) = 1.0_rk volume(i) = mass(i) / rho(i) + explosive_initial_material_id(i) = mat_index + explosive_initial_mass(i) = mass(i) + explosive_remaining_mass(i) = mass(i) end do + call sph_explosive_update_release_balance() end subroutine sph_explosive_apply_initial_conditions subroutine sph_explosive_advance(dt, time, ierr) @@ -387,10 +406,12 @@ contains if (lambda_target > 1.0_rk) lambda_target = 1.0_rk delta_lambda = lambda_target - lambda_old if (delta_lambda <= 0.0_rk) cycle - release_mass = delta_lambda * mass(i) + release_mass = delta_lambda * explosive_initial_mass(i) release_energy = release_mass * explosive_energy_per_mass(explosive_index) release_momentum = release_mass * v(:,i) explosive_reaction_progress(i) = lambda_target + explosive_remaining_mass(i) = max(0.0_rk, & + explosive_initial_mass(i) * (1.0_rk - lambda_target)) explosive_released_mass(i) = explosive_released_mass(i) + release_mass explosive_released_energy(i) = explosive_released_energy(i) + release_energy explosive_released_momentum(:,i) = explosive_released_momentum(:,i) + & @@ -404,6 +425,7 @@ contains if (ierr /= SPH_SUCCESS) return end if end do + call sph_explosive_update_release_balance() end subroutine sph_explosive_advance real(rk) function sph_explosive_reaction_target(index, explosive_index, time) @@ -529,6 +551,7 @@ contains detonation_time_range = 0.0_rk first_value = .true. if (.not. allocated(explosive_reaction_progress)) return + call sph_explosive_update_release_balance() do i = 1, npart if (.not. sph_explosive_is_tracked_particle(i)) cycle particle_count = particle_count + 1 @@ -562,6 +585,57 @@ contains lambda_range(3) / real(particle_count, rk) end subroutine sph_explosive_get_summary + subroutine sph_explosive_update_release_balance() + integer :: i + integer :: explosive_index + real(rk) :: expected_energy + + explosive_release_mass_balance = 0.0_rk + explosive_release_energy_balance = 0.0_rk + explosive_release_momentum_balance = 0.0_rk + if (.not. allocated(explosive_initial_mass)) return + expected_energy = 0.0_rk + do i = 1, npart + if (.not. sph_explosive_is_tracked_particle(i)) cycle + explosive_release_mass_balance(1) = explosive_release_mass_balance(1) + & + explosive_initial_mass(i) + explosive_release_mass_balance(2) = explosive_release_mass_balance(2) + & + explosive_released_mass(i) + explosive_release_mass_balance(3) = explosive_release_mass_balance(3) + & + explosive_remaining_mass(i) + explosive_release_energy_balance(1) = explosive_release_energy_balance(1) + & + explosive_released_energy(i) + explosive_release_momentum_balance = explosive_release_momentum_balance + & + explosive_released_momentum(:,i) + explosive_index = sph_explosive_table_index_by_material_id( & + explosive_initial_material_id(i)) + if (explosive_index > 0) then + expected_energy = expected_energy + explosive_released_mass(i) * & + explosive_energy_per_mass(explosive_index) + else + expected_energy = expected_energy + explosive_released_energy(i) + end if + end do + explosive_release_mass_balance(4) = explosive_release_mass_balance(1) - & + explosive_release_mass_balance(2) - explosive_release_mass_balance(3) + explosive_release_energy_balance(2) = explosive_release_energy_balance(1) - & + expected_energy + end subroutine sph_explosive_update_release_balance + + subroutine sph_explosive_get_release_balance(mass_values, energy_values, & + momentum_values, ierr) + real(rk), intent(out) :: mass_values(4) + real(rk), intent(out) :: energy_values(2) + real(rk), intent(out) :: momentum_values(SPH_NDIM) + integer, intent(out) :: ierr + + call sph_explosive_update_release_balance() + mass_values = explosive_release_mass_balance + energy_values = explosive_release_energy_balance + momentum_values = explosive_release_momentum_balance + ierr = SPH_SUCCESS + end subroutine sph_explosive_get_release_balance + subroutine sph_explosive_set_default_ignition_point(ignition_x, & ignition_time, ierr) real(rk), intent(in) :: ignition_x(SPH_NDIM) diff --git a/src/explosive/sph_explosive_state.f90 b/src/explosive/sph_explosive_state.f90 index c88d4dc..e14d20b 100644 --- a/src/explosive/sph_explosive_state.f90 +++ b/src/explosive/sph_explosive_state.f90 @@ -27,9 +27,15 @@ module sph_explosive_state integer, allocatable :: explosive_ignition_status(:) real(rk), allocatable :: explosive_detonation_time(:) real(rk), allocatable :: explosive_reaction_progress(:) + integer, allocatable :: explosive_initial_material_id(:) + real(rk), allocatable :: explosive_initial_mass(:) + real(rk), allocatable :: explosive_remaining_mass(:) real(rk), allocatable :: explosive_released_mass(:) real(rk), allocatable :: explosive_released_energy(:) real(rk), allocatable :: explosive_released_momentum(:,:) + real(rk) :: explosive_release_mass_balance(4) = 0.0_rk + real(rk) :: explosive_release_energy_balance(2) = 0.0_rk + real(rk) :: explosive_release_momentum_balance(SPH_NDIM) = 0.0_rk real(rk) :: explosive_dt_reaction = 0.0_rk end module sph_explosive_state diff --git a/tests/module/test_explosive_initial_mass_release.f90 b/tests/module/test_explosive_initial_mass_release.f90 new file mode 100644 index 0000000..6cdc562 --- /dev/null +++ b/tests/module/test_explosive_initial_mass_release.f90 @@ -0,0 +1,68 @@ +program test_explosive_initial_mass_release + 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, sph_advance_explicit + use sph_database, only: mass + use sph_explosive_state, only: explosive_initial_mass, & + explosive_remaining_mass, explosive_released_mass, & + explosive_reaction_progress + implicit none + + call assert_frozen_release('tests/data/explosive_conversion_phase_040.inp', & + 'PHASE') + call assert_frozen_release('tests/data/explosive_conversion_source_040.inp', & + 'SOURCE') + +contains + + subroutine assert_frozen_release(filename, label) + character(len=*), intent(in) :: filename + character(len=*), intent(in) :: label + integer :: ierr + real(rk) :: frozen_mass + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for ' // label) + call sph_read_inp(filename, ierr) + call assert_ok(ierr, 'read failed for ' // label) + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for ' // label) + frozen_mass = explosive_initial_mass(1) + if (frozen_mass <= 0.0_rk) call fail('initial mass not frozen for ' // label) + mass(1) = 10.0_rk * frozen_mass + call sph_advance_explicit(1.0e-7_rk, ierr) + call assert_ok(ierr, 'advance failed for ' // label) + call assert_close(explosive_released_mass(1), frozen_mass, & + 'release did not use frozen mass for ' // label) + call assert_close(explosive_remaining_mass(1), 0.0_rk, & + 'remaining mass mismatch for ' // label) + call assert_close(explosive_reaction_progress(1), 1.0_rk, & + 'lambda mismatch for ' // label) + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for ' // label) + end subroutine assert_frozen_release + + 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 assert_close(actual, expected, message) + real(rk), intent(in) :: actual + real(rk), intent(in) :: expected + character(len=*), intent(in) :: message + + if (abs(actual - expected) > 1.0e-12_rk) call fail(message) + end subroutine assert_close + + subroutine fail(message) + character(len=*), intent(in) :: message + + write(*, '(A)') trim(message) + stop 1 + end subroutine fail + +end program test_explosive_initial_mass_release diff --git a/tests/module/test_explosive_release_balance.f90 b/tests/module/test_explosive_release_balance.f90 new file mode 100644 index 0000000..8847973 --- /dev/null +++ b/tests/module/test_explosive_release_balance.f90 @@ -0,0 +1,117 @@ +program test_explosive_release_balance + 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, sph_advance_explicit + use sph_database, only: v + use sph_explosive, only: sph_explosive_get_release_balance + use sph_explosive_state, only: explosive_initial_mass, & + explosive_remaining_mass, explosive_released_mass, & + explosive_released_energy, explosive_released_momentum + implicit none + + call assert_empty_balance() + call assert_active_balance() + +contains + + subroutine assert_empty_balance() + integer :: ierr + real(rk) :: mass_values(4) + real(rk) :: energy_values(2) + real(rk) :: momentum_values(3) + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize empty balance failed') + call sph_read_inp('tests/data/water_minimal_020.inp', ierr) + call assert_ok(ierr, 'read empty balance failed') + call sph_build_model(ierr) + call assert_ok(ierr, 'build empty balance failed') + call sph_explosive_get_release_balance(mass_values, energy_values, & + momentum_values, ierr) + call assert_ok(ierr, 'query empty balance failed') + if (maxval(abs(mass_values)) > 1.0e-12_rk) call fail('empty mass balance mismatch') + if (maxval(abs(energy_values)) > 1.0e-12_rk) call fail('empty energy balance mismatch') + if (maxval(abs(momentum_values)) > 1.0e-12_rk) then + call fail('empty momentum balance mismatch') + end if + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize empty balance failed') + end subroutine assert_empty_balance + + subroutine assert_active_balance() + integer :: ierr + real(rk) :: mass_values(4) + real(rk) :: energy_values(2) + real(rk) :: momentum_values(3) + real(rk) :: expected_initial + real(rk) :: expected_released + real(rk) :: expected_remaining + real(rk) :: expected_energy + real(rk) :: expected_momentum(3) + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize active balance failed') + call sph_read_inp('tests/data/explosive_conversion_phase_040.inp', ierr) + call assert_ok(ierr, 'read active balance failed') + call sph_build_model(ierr) + call assert_ok(ierr, 'build active balance failed') + v(:,1) = (/2.0_rk, -3.0_rk, 4.0_rk/) + call sph_advance_explicit(1.0e-7_rk, ierr) + call assert_ok(ierr, 'advance active balance failed') + call sph_explosive_get_release_balance(mass_values, energy_values, & + momentum_values, ierr) + call assert_ok(ierr, 'query active balance failed') + expected_initial = sum(explosive_initial_mass(1:4)) + expected_released = sum(explosive_released_mass(1:4)) + expected_remaining = sum(explosive_remaining_mass(1:4)) + expected_energy = sum(explosive_released_energy(1:4)) + expected_momentum = 0.0_rk + expected_momentum(1) = sum(explosive_released_momentum(1,1:4)) + expected_momentum(2) = sum(explosive_released_momentum(2,1:4)) + expected_momentum(3) = sum(explosive_released_momentum(3,1:4)) + call assert_close(mass_values(1), expected_initial, 'initial mass mismatch') + call assert_close(mass_values(2), expected_released, 'released mass mismatch') + call assert_close(mass_values(3), expected_remaining, 'remaining mass mismatch') + call assert_close(mass_values(4), 0.0_rk, 'mass closure mismatch') + call assert_close(energy_values(1), expected_energy, 'released energy mismatch') + call assert_close(energy_values(2), 0.0_rk, 'energy closure mismatch') + call assert_vector_close(momentum_values, expected_momentum, & + 'released momentum mismatch') + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize active balance failed') + end subroutine assert_active_balance + + 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 assert_vector_close(actual, expected, message) + real(rk), intent(in) :: actual(3) + real(rk), intent(in) :: expected(3) + character(len=*), intent(in) :: message + + if (maxval(abs(actual - expected)) > 1.0e-12_rk) call fail(message) + end subroutine assert_vector_close + + subroutine assert_close(actual, expected, message) + real(rk), intent(in) :: actual + real(rk), intent(in) :: expected + character(len=*), intent(in) :: message + + if (abs(actual - expected) > 1.0e-12_rk * max(1.0_rk, abs(expected))) then + call fail(message) + end if + end subroutine assert_close + + subroutine fail(message) + character(len=*), intent(in) :: message + + write(*, '(A)') trim(message) + stop 1 + end subroutine fail + +end program test_explosive_release_balance diff --git a/todo.md b/todo.md index 93aa17b..1f17395 100644 --- a/todo.md +++ b/todo.md @@ -56,26 +56,26 @@ ## 阶段 C:反应质量基准与释放量一致性 -- [ ] 新增每粒子 Explosive 反应质量基准状态。 -- [ ] 在 Explosive 状态分配过程中分配反应质量基准数组。 -- [ ] 在 Explosive 状态清理过程中清零反应质量基准数组。 -- [ ] 在模型构建阶段从当前粒子质量冻结反应质量基准。 -- [ ] 确认无 Explosive 输入时反应质量基准不影响 Water/Gas 算例。 -- [ ] 将 SOURCE 路径释放质量改为使用冻结反应质量基准。 -- [ ] 将 PHASE 路径释放质量改为使用冻结反应质量基准。 -- [ ] 保持 `delta_lambda` 作为唯一释放增量来源。 -- [ ] 保持 `lambda` 单调不可逆并限制在 `[0,1]`。 -- [ ] 保持 `burn_time = 0` 的瞬时反应行为。 -- [ ] 保持 `burn_time > 0` 的线性反应窗口行为。 -- [ ] 计算每粒子剩余可反应质量。 -- [ ] 计算全局 Explosive 初始反应质量。 -- [ ] 计算全局 Explosive 累计释放质量。 -- [ ] 计算全局 Explosive 剩余可反应质量。 -- [ ] 计算释放质量闭合误差诊断。 -- [ ] 计算释放能量闭合误差诊断。 -- [ ] 计算三向释放动量合计诊断。 -- [ ] 新增初始质量释放一致性测试并接入 CTest。 -- [ ] 新增 release balance 模块测试并接入 CTest。 +- [x] 新增每粒子 Explosive 反应质量基准状态。 +- [x] 在 Explosive 状态分配过程中分配反应质量基准数组。 +- [x] 在 Explosive 状态清理过程中清零反应质量基准数组。 +- [x] 在模型构建阶段从当前粒子质量冻结反应质量基准。 +- [x] 确认无 Explosive 输入时反应质量基准不影响 Water/Gas 算例。 +- [x] 将 SOURCE 路径释放质量改为使用冻结反应质量基准。 +- [x] 将 PHASE 路径释放质量改为使用冻结反应质量基准。 +- [x] 保持 `delta_lambda` 作为唯一释放增量来源。 +- [x] 保持 `lambda` 单调不可逆并限制在 `[0,1]`。 +- [x] 保持 `burn_time = 0` 的瞬时反应行为。 +- [x] 保持 `burn_time > 0` 的线性反应窗口行为。 +- [x] 计算每粒子剩余可反应质量。 +- [x] 计算全局 Explosive 初始反应质量。 +- [x] 计算全局 Explosive 累计释放质量。 +- [x] 计算全局 Explosive 剩余可反应质量。 +- [x] 计算释放质量闭合误差诊断。 +- [x] 计算释放能量闭合误差诊断。 +- [x] 计算三向释放动量合计诊断。 +- [x] 新增初始质量释放一致性测试并接入 CTest。 +- [x] 新增 release balance 模块测试并接入 CTest。 ## 阶段 D:SOURCE、PHASE、混合链路与输出