From 708016c9af418e58d85008776a9259e0b3244d2f Mon Sep 17 00:00:00 2001 From: Codex Date: Fri, 3 Jul 2026 16:21:51 +0800 Subject: [PATCH] Expose Solid summary interfaces --- CMakeLists.txt | 32 +++++++++-- Python/sphlite_debug.py | 54 +++++++++++-------- include/sphlite.hpp | 41 ++++++++++++++ include/sphlite_c_api.h | 6 +++ src/app/sph_main.c | 28 ++++++++++ src/interface/sph_api.f90 | 83 ++++++++++++++++++++++++++++ src/interface/sph_c_api.c | 44 +++++++++++++++ src/solid/sph_solid_dynamics.f90 | 42 +++++++++++++++ src/solid/sph_solid_restart.f90 | 7 ++- tests/interface/test_c_api.c | 33 ++++++++++++ tests/interface/test_cpp_api.cpp | 7 +++ todo.md | 44 +++++++-------- tools/testing/test_cli.py | 20 +++++++ tools/testing/test_python_debug.py | 9 ++++ tools/testing/test_solid_cli.py | 87 ++++++++++++++++++++++++++++++ 15 files changed, 486 insertions(+), 51 deletions(-) create mode 100644 tools/testing/test_solid_cli.py diff --git a/CMakeLists.txt b/CMakeLists.txt index fa6f848..61980b5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,6 +57,8 @@ if(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU") #define SPHLITE_FC_sphft_set_ignition_point sphft_set_ignition_point_ #define SPHLITE_FC_sphft_get_explosive_summary sphft_get_explosive_summary_ #define SPHLITE_FC_sphft_get_explosive_release_balance sphft_get_explosive_release_balance_ +#define SPHLITE_FC_sphft_get_solid_counts sphft_get_solid_counts_ +#define SPHLITE_FC_sphft_get_solid_summary sphft_get_solid_summary_ #endif ") endif() @@ -258,6 +260,8 @@ add_test(NAME explosive_c_api COMMAND test_c_api) set_tests_properties(explosive_c_api PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") add_test(NAME explosive_release_c_api COMMAND test_c_api) set_tests_properties(explosive_release_c_api PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_test(NAME solid_c_api COMMAND test_c_api) +set_tests_properties(solid_c_api PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") add_executable(test_cpp_api tests/interface/test_cpp_api.cpp) target_include_directories(test_cpp_api PRIVATE include) @@ -518,7 +522,7 @@ add_test( COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tools/testing/test_python_debug.py" --library "$" - --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/minimal_particles.inp" + --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/minimal_particles_011.inp" ) set_tests_properties(python_debug PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") @@ -527,7 +531,7 @@ add_test( COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tools/testing/test_python_debug.py" --library "$" - --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/minimal_particles.inp" + --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/minimal_particles_011.inp" ) set_tests_properties(explosive_python PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") @@ -536,7 +540,7 @@ add_test( COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tools/testing/test_python_debug.py" --library "$" - --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/minimal_particles.inp" + --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/minimal_particles_011.inp" ) set_tests_properties(explosive_release_python PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") @@ -545,10 +549,19 @@ add_test( COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tools/testing/test_python_debug.py" --library "$" - --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/minimal_particles.inp" + --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/minimal_particles_011.inp" ) set_tests_properties(gas_python_extended PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_test( + NAME solid_python + COMMAND "${Python3_EXECUTABLE}" + "${CMAKE_CURRENT_SOURCE_DIR}/tools/testing/test_python_debug.py" + --library "$" + --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/solid_elastic_minimal_050.inp" +) +set_tests_properties(solid_python PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_test( NAME cli COMMAND "${Python3_EXECUTABLE}" @@ -593,6 +606,17 @@ add_test( ) set_tests_properties(gas_cli_extended PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_test( + NAME solid_cli + COMMAND "${Python3_EXECUTABLE}" + "${CMAKE_CURRENT_SOURCE_DIR}/tools/testing/test_solid_cli.py" + --exe "$" + --library "$" + --input "${CMAKE_CURRENT_SOURCE_DIR}/tests/data/solid_elastic_minimal_050.inp" + --output-dir "${CMAKE_BINARY_DIR}" +) +set_tests_properties(solid_cli PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_test( NAME source_size COMMAND "${Python3_EXECUTABLE}" diff --git a/Python/sphlite_debug.py b/Python/sphlite_debug.py index fbd4e28..f15e9cb 100644 --- a/Python/sphlite_debug.py +++ b/Python/sphlite_debug.py @@ -30,14 +30,12 @@ class SPHLite: self._configure() def _configure(self) -> None: + int_p = ctypes.POINTER(ctypes.c_int) + double_p = ctypes.POINTER(ctypes.c_double) self.lib.sphlite_initialize.restype = ctypes.c_int self.lib.sphlite_finalize.restype = ctypes.c_int - self.lib.sphlite_get_version.argtypes = [ - ctypes.POINTER(ctypes.c_int), - ctypes.POINTER(ctypes.c_int), - ctypes.POINTER(ctypes.c_int), - ] + self.lib.sphlite_get_version.argtypes = [int_p, int_p, int_p] self.lib.sphlite_get_version.restype = ctypes.c_int self.lib.sphlite_read_inp.argtypes = [ctypes.c_char_p] @@ -67,28 +65,13 @@ class SPHLite: self.lib.sphlite_read_restart.argtypes = [ctypes.c_char_p] self.lib.sphlite_read_restart.restype = ctypes.c_int - self.lib.sphlite_get_water_summary.argtypes = [ - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ] + self.lib.sphlite_get_water_summary.argtypes = [double_p] * 5 self.lib.sphlite_get_water_summary.restype = ctypes.c_int - self.lib.sphlite_get_water_dt_limits.argtypes = [ - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ] + self.lib.sphlite_get_water_dt_limits.argtypes = [double_p] * 3 self.lib.sphlite_get_water_dt_limits.restype = ctypes.c_int - self.lib.sphlite_get_gas_summary.argtypes = [ - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ctypes.POINTER(ctypes.c_double), - ] + self.lib.sphlite_get_gas_summary.argtypes = [double_p] * 4 self.lib.sphlite_get_gas_summary.restype = ctypes.c_int self.lib.sphlite_get_gas_bubble_metrics.argtypes = [ @@ -142,6 +125,9 @@ class SPHLite: ctypes.POINTER(ctypes.c_double), ] self.lib.sphlite_get_explosive_release_balance.restype = ctypes.c_int + self.lib.sphlite_get_solid_summary.argtypes = [ctypes.POINTER(ctypes.c_int), + ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_double), ctypes.c_int] + self.lib.sphlite_get_solid_summary.restype = ctypes.c_int self.lib.sphlite_get_particle_state.argtypes = [ ctypes.c_int, @@ -454,6 +440,26 @@ class SPHLite: "explosive_release_momentum_values": list(momentum_values), } + def solid_summary(self) -> dict[str, int | float | list[float]]: + active, failed = ctypes.c_int(0), ctypes.c_int(0) + values = (ctypes.c_double * 16)() + self._check(self.lib.sphlite_get_solid_summary( + ctypes.byref(active), ctypes.byref(failed), values, len(values))) + v = list(values) + return { + "solid_particles": int(active.value), + "solid_failed_particles": int(failed.value), + "solid_mass": float(v[0]), + "solid_momentum": v[1:4], + "solid_kinetic_energy": float(v[4]), + "solid_internal_energy": float(v[5]), + "solid_max_von_mises": float(v[6]), + "solid_plastic_strain_range": v[7:9], + "solid_damage_range": v[9:11], + "solid_softening_range": v[11:13], + "solid_dt_limits": v[13:16], + } + def inspect(self, filename: str | Path) -> dict[str, int | float | list[float]]: self.read_inp(filename) self.build_model() @@ -470,6 +476,7 @@ class SPHLite: summary.update(self.gas_source_summary()) summary.update(self.explosive_summary()) summary.update(self.explosive_release_balance()) + summary.update(self.solid_summary()) return summary def run(self, filename: str | Path) -> dict[str, int | float | list[float]]: @@ -485,4 +492,5 @@ class SPHLite: summary.update(self.gas_source_summary()) summary.update(self.explosive_summary()) summary.update(self.explosive_release_balance()) + summary.update(self.solid_summary()) return summary diff --git a/include/sphlite.hpp b/include/sphlite.hpp index 7ad1d2c..f47d640 100644 --- a/include/sphlite.hpp +++ b/include/sphlite.hpp @@ -110,6 +110,20 @@ struct ExplosiveReleaseBalance { double momentum_values[3]; }; +struct SolidSummary { + int active_count; + int failed_count; + double mass; + double momentum[3]; + double kinetic_energy; + double internal_energy; + double max_von_mises; + double plastic_strain_range[2]; + double damage_range[2]; + double softening_range[2]; + double dt_limits[3]; +}; + class Error : public std::runtime_error { public: explicit Error(const std::string &message) : std::runtime_error(message) {} @@ -278,6 +292,33 @@ inline ExplosiveReleaseBalance explosive_release_balance() return balance; } +inline SolidSummary solid_summary() +{ + SolidSummary summary = { + 0, 0, 0.0, {0.0, 0.0, 0.0}, 0.0, 0.0, 0.0, + {0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0, 0.0}}; + double values[SPHLITE_SOLID_SUMMARY_VALUE_COUNT] = {0.0}; + check(sphlite_get_solid_summary(&summary.active_count, + &summary.failed_count, values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT)); + summary.mass = values[0]; + summary.momentum[0] = values[1]; + summary.momentum[1] = values[2]; + summary.momentum[2] = values[3]; + summary.kinetic_energy = values[4]; + summary.internal_energy = values[5]; + summary.max_von_mises = values[6]; + summary.plastic_strain_range[0] = values[7]; + summary.plastic_strain_range[1] = values[8]; + summary.damage_range[0] = values[9]; + summary.damage_range[1] = values[10]; + summary.softening_range[0] = values[11]; + summary.softening_range[1] = values[12]; + summary.dt_limits[0] = values[13]; + summary.dt_limits[1] = values[14]; + summary.dt_limits[2] = values[15]; + return summary; +} + inline void set_output_directory(const std::string &path) { check(sphlite_set_output_directory(path.c_str())); diff --git a/include/sphlite_c_api.h b/include/sphlite_c_api.h index 9c0b0b7..225d8c0 100644 --- a/include/sphlite_c_api.h +++ b/include/sphlite_c_api.h @@ -30,6 +30,8 @@ extern "C" { #define SPHLITE_STATUS_FAILED 2 #define SPHLITE_STATUS_RESERVED 3 +#define SPHLITE_SOLID_SUMMARY_VALUE_COUNT 16 + SPHLITE_API int sphlite_initialize(void); SPHLITE_API int sphlite_finalize(void); SPHLITE_API int sphlite_get_version(int *major, int *minor, int *patch); @@ -97,6 +99,10 @@ SPHLITE_API int sphlite_get_explosive_summary(int *particle_count, SPHLITE_API int sphlite_get_explosive_release_balance(double *mass_values, double *energy_values, double *momentum_values); +SPHLITE_API int sphlite_get_solid_summary(int *active_count, + int *failed_count, + double *values, + int value_capacity); #ifdef __cplusplus } diff --git a/src/app/sph_main.c b/src/app/sph_main.c index 15d782a..d8bf96a 100644 --- a/src/app/sph_main.c +++ b/src/app/sph_main.c @@ -138,6 +138,9 @@ int main(int argc, char **argv) double explosive_release_mass_values[4] = {0.0, 0.0, 0.0, 0.0}; double explosive_release_energy_values[2] = {0.0, 0.0}; double explosive_release_momentum_values[3] = {0.0, 0.0, 0.0}; + int solid_particles = 0; + int solid_failed_particles = 0; + double solid_values[SPHLITE_SOLID_SUMMARY_VALUE_COUNT] = {0.0}; int run_mode = 0; int check_mode = 0; const char *input = NULL; @@ -336,6 +339,13 @@ int main(int argc, char **argv) (void)sphlite_finalize(); return 1; } + ierr = sphlite_get_solid_summary(&solid_particles, &solid_failed_particles, + solid_values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT); + if (ierr != 0) { + sphlite_print_error(); + (void)sphlite_finalize(); + return 1; + } printf("version: %d.%d.%d\n", major, minor, patch); printf("input: %s\n", input); @@ -391,6 +401,24 @@ int main(int argc, char **argv) printf("explosive_release_momentum_x: %.16e\n", explosive_release_momentum_values[0]); printf("explosive_release_momentum_y: %.16e\n", explosive_release_momentum_values[1]); printf("explosive_release_momentum_z: %.16e\n", explosive_release_momentum_values[2]); + printf("solid_particles: %d\n", solid_particles); + printf("solid_failed_particles: %d\n", solid_failed_particles); + printf("solid_mass: %.16e\n", solid_values[0]); + printf("solid_momentum_x: %.16e\n", solid_values[1]); + printf("solid_momentum_y: %.16e\n", solid_values[2]); + printf("solid_momentum_z: %.16e\n", solid_values[3]); + printf("solid_kinetic_energy: %.16e\n", solid_values[4]); + printf("solid_internal_energy: %.16e\n", solid_values[5]); + printf("solid_max_von_mises: %.16e\n", solid_values[6]); + printf("solid_plastic_strain_min: %.16e\n", solid_values[7]); + printf("solid_plastic_strain_max: %.16e\n", solid_values[8]); + printf("solid_damage_min: %.16e\n", solid_values[9]); + printf("solid_damage_max: %.16e\n", solid_values[10]); + printf("solid_softening_min: %.16e\n", solid_values[11]); + printf("solid_softening_max: %.16e\n", solid_values[12]); + printf("solid_dt_cfl: %.16e\n", solid_values[13]); + printf("solid_dt_accel: %.16e\n", solid_values[14]); + printf("solid_dtcrit: %.16e\n", solid_values[15]); printf("status: ok\n"); ierr = sphlite_finalize(); diff --git a/src/interface/sph_api.f90 b/src/interface/sph_api.f90 index cc1d12e..8745448 100644 --- a/src/interface/sph_api.f90 +++ b/src/interface/sph_api.f90 @@ -28,6 +28,7 @@ module sph_api sph_explosive_get_summary, sph_explosive_get_release_balance, & sph_explosive_set_default_ignition_point use sph_solid, only: sph_solid_initialize, sph_solid_reset + use sph_solid_dynamics, only: sph_solid_get_counts, sph_solid_get_summary use sph_shell, only: sph_shell_initialize, sph_shell_reset use sph_api_state, only: sph_api_initialized, sph_api_model_built, & sph_api_state_set_initialized, sph_api_state_set_model_built @@ -495,6 +496,55 @@ contains momentum_values, ierr) end subroutine sph_get_explosive_release_balance + subroutine sph_get_solid_counts(active_count, failed_count, ierr) + integer, intent(out) :: active_count + integer, intent(out) :: failed_count + integer, intent(out) :: ierr + + active_count = 0 + failed_count = 0 + call sph_api_require_initialized(ierr) + if (ierr /= SPH_SUCCESS) return + call sph_api_require_model_built(ierr) + if (ierr /= SPH_SUCCESS) return + call sph_solid_get_counts(active_count, failed_count) + ierr = SPH_SUCCESS + end subroutine sph_get_solid_counts + + subroutine sph_get_solid_summary(active_count, failed_count, mass, momentum, & + energy, max_von_mises, plastic_range, damage_range, softening_range, & + dt_limits, ierr) + integer, intent(out) :: active_count + integer, intent(out) :: failed_count + real(rk), intent(out) :: mass + real(rk), intent(out) :: momentum(3) + real(rk), intent(out) :: energy(2) + real(rk), intent(out) :: max_von_mises + real(rk), intent(out) :: plastic_range(2) + real(rk), intent(out) :: damage_range(2) + real(rk), intent(out) :: softening_range(2) + real(rk), intent(out) :: dt_limits(3) + integer, intent(out) :: ierr + + active_count = 0 + failed_count = 0 + mass = 0.0_rk + momentum = 0.0_rk + energy = 0.0_rk + max_von_mises = 0.0_rk + plastic_range = 0.0_rk + damage_range = 0.0_rk + softening_range = 0.0_rk + dt_limits = 0.0_rk + call sph_api_require_initialized(ierr) + if (ierr /= SPH_SUCCESS) return + call sph_api_require_model_built(ierr) + if (ierr /= SPH_SUCCESS) return + call sph_solid_get_summary(active_count, failed_count, mass, momentum, & + energy, max_von_mises, plastic_range, damage_range, softening_range, & + dt_limits, ierr) + end subroutine sph_get_solid_summary + subroutine sph_api_require_initialized(ierr) integer, intent(out) :: ierr @@ -819,6 +869,39 @@ subroutine sphft_get_explosive_release_balance(mass_values, energy_values, & momentum_values, ierr) end subroutine sphft_get_explosive_release_balance +subroutine sphft_get_solid_counts(active_count, failed_count, ierr) + use sph_api, only: sph_get_solid_counts + implicit none + integer, intent(out) :: active_count + integer, intent(out) :: failed_count + integer, intent(out) :: ierr + + call sph_get_solid_counts(active_count, failed_count, ierr) +end subroutine sphft_get_solid_counts + +subroutine sphft_get_solid_summary(active_count, failed_count, mass, momentum, & + energy, max_von_mises, plastic_range, damage_range, softening_range, & + dt_limits, ierr) + use sph_api, only: sph_get_solid_summary + use sph_precision, only: rk + implicit none + integer, intent(out) :: active_count + integer, intent(out) :: failed_count + real(rk), intent(out) :: mass + real(rk), intent(out) :: momentum(3) + real(rk), intent(out) :: energy(2) + real(rk), intent(out) :: max_von_mises + real(rk), intent(out) :: plastic_range(2) + real(rk), intent(out) :: damage_range(2) + real(rk), intent(out) :: softening_range(2) + real(rk), intent(out) :: dt_limits(3) + integer, intent(out) :: ierr + + call sph_get_solid_summary(active_count, failed_count, mass, momentum, & + energy, max_von_mises, plastic_range, damage_range, softening_range, & + dt_limits, ierr) +end subroutine sphft_get_solid_summary + subroutine sphft_set_output_directory_chars(chars, count, ierr) use sph_api, only: sph_set_output_directory implicit none diff --git a/src/interface/sph_c_api.c b/src/interface/sph_c_api.c index 00f45d6..f82148b 100644 --- a/src/interface/sph_c_api.c +++ b/src/interface/sph_c_api.c @@ -101,6 +101,10 @@ extern void SPHLITE_FC_sphft_get_explosive_release_balance( double *energy_values, double *momentum_values, int *ierr); +extern void SPHLITE_FC_sphft_get_solid_summary(int *active_count, + int *failed_count, double *mass, double *momentum, double *energy, + double *max_von_mises, double *plastic_range, double *damage_range, + double *softening_range, double *dt_limits, int *ierr); static int sphlite_call_path( const char *path, @@ -454,3 +458,43 @@ int sphlite_get_explosive_release_balance(double *mass_values, energy_values, momentum_values, &ierr); return ierr; } + +int sphlite_get_solid_summary(int *active_count, int *failed_count, + double *values, + int value_capacity) +{ + int ierr = 0; + double mass = 0.0; + double momentum[3] = {0.0, 0.0, 0.0}; + double energy[2] = {0.0, 0.0}; + double max_von_mises = 0.0; + double plastic_range[2] = {0.0, 0.0}; + double damage_range[2] = {0.0, 0.0}; + double softening_range[2] = {0.0, 0.0}; + double dt_limits[3] = {0.0, 0.0, 0.0}; + int i; + + if (active_count == NULL || failed_count == NULL || values == NULL || + value_capacity < SPHLITE_SOLID_SUMMARY_VALUE_COUNT) { + return -1; + } + SPHLITE_FC_sphft_get_solid_summary(active_count, failed_count, &mass, + momentum, energy, &max_von_mises, plastic_range, damage_range, + softening_range, dt_limits, &ierr); + if (ierr != 0) { + return ierr; + } + values[0] = mass; + values[6] = max_von_mises; + for (i = 0; i < 3; ++i) { + values[1 + i] = momentum[i]; + values[13 + i] = dt_limits[i]; + } + for (i = 0; i < 2; ++i) { + values[4 + i] = energy[i]; + values[7 + i] = plastic_range[i]; + values[9 + i] = damage_range[i]; + values[11 + i] = softening_range[i]; + } + return ierr; +} diff --git a/src/solid/sph_solid_dynamics.f90 b/src/solid/sph_solid_dynamics.f90 index f490065..a6f722d 100644 --- a/src/solid/sph_solid_dynamics.f90 +++ b/src/solid/sph_solid_dynamics.f90 @@ -39,6 +39,48 @@ contains end do end subroutine sph_solid_get_counts + subroutine sph_solid_get_summary(active_count, failed_count, mass_out, & + momentum_out, energy_out, max_von_mises_out, plastic_range_out, & + damage_range_out, softening_range_out, dt_limits_out, ierr) + integer, intent(out) :: active_count + integer, intent(out) :: failed_count + real(rk), intent(out) :: mass_out + real(rk), intent(out) :: momentum_out(SPH_NDIM) + real(rk), intent(out) :: energy_out(2) + real(rk), intent(out) :: max_von_mises_out + real(rk), intent(out) :: plastic_range_out(2) + real(rk), intent(out) :: damage_range_out(2) + real(rk), intent(out) :: softening_range_out(2) + real(rk), intent(out) :: dt_limits_out(3) + integer, intent(out) :: ierr + + active_count = 0 + failed_count = 0 + mass_out = 0.0_rk + momentum_out = 0.0_rk + energy_out = 0.0_rk + max_von_mises_out = 0.0_rk + plastic_range_out = 0.0_rk + damage_range_out = 0.0_rk + softening_range_out = 0.0_rk + dt_limits_out = 0.0_rk + call sph_solid_update_diagnostics(ierr) + if (ierr /= SPH_SUCCESS) return + call sph_solid_estimate_dt_limits(dt_limits_out(1), dt_limits_out(2), & + dt_limits_out(3), ierr) + if (ierr /= SPH_SUCCESS) return + active_count = solid_particle_count + failed_count = solid_failed_count + mass_out = solid_mass + momentum_out = solid_momentum + energy_out(1) = solid_kinetic_energy + energy_out(2) = solid_internal_energy_total + max_von_mises_out = solid_max_von_mises + plastic_range_out = (/solid_min_plastic_strain, solid_max_plastic_strain/) + damage_range_out = (/solid_min_damage, solid_max_damage/) + softening_range_out = (/solid_min_softening, solid_max_softening/) + end subroutine sph_solid_get_summary + subroutine sph_solid_build_reference_state(ierr) integer, intent(out) :: ierr integer :: i diff --git a/src/solid/sph_solid_restart.f90 b/src/solid/sph_solid_restart.f90 index f2b4544..4cb4140 100644 --- a/src/solid/sph_solid_restart.f90 +++ b/src/solid/sph_solid_restart.f90 @@ -1,7 +1,7 @@ module sph_solid_restart use sph_precision, only: rk use sph_error, only: SPH_SUCCESS - use sph_database, only: npart, SPH_MAX_MATERIALS, solid_particle_count, & + use sph_database, only: npart, SPH_MAX_MATERIALS, SPH_NAME_LEN, solid_particle_count, & solid_failed_count, solid_mass, solid_momentum, solid_kinetic_energy, & solid_internal_energy_total, solid_max_von_mises, & solid_min_plastic_strain, solid_max_plastic_strain, solid_min_damage, & @@ -30,9 +30,12 @@ contains subroutine sph_solid_restart_write(unit) integer, intent(in) :: unit integer :: i + character(len=SPH_NAME_LEN) :: softening_name write(unit, *) solid_material_seen, solid_material_count do i = 1, solid_material_count + softening_name = solid_softening_type(i) + if (len_trim(softening_name) == 0) softening_name = 'NONE' write(unit, *) solid_material_ids(i), trim(solid_material_names(i)), & solid_elastic_defined(i), solid_johnson_cook_defined(i), & solid_failure_defined(i), solid_control_defined(i) @@ -41,7 +44,7 @@ contains solid_jc_c(i), solid_jc_m(i), solid_jc_epsdot0(i), & solid_jc_troom(i), solid_jc_tmelt(i) write(unit, *) solid_failure_d(:,i) - write(unit, *) trim(solid_softening_type(i)), solid_softening_width(i) + write(unit, *) trim(softening_name), solid_softening_width(i) write(unit, *) solid_density(i), solid_shear_modulus(i), & solid_bulk_modulus(i), solid_wave_speed(i), solid_temperature_rise_factor(i) end do diff --git a/tests/interface/test_c_api.c b/tests/interface/test_c_api.c index c59402c..cff0028 100644 --- a/tests/interface/test_c_api.c +++ b/tests/interface/test_c_api.c @@ -63,6 +63,9 @@ int main(void) double explosive_release_mass_values[4] = {0.0, 0.0, 0.0, 0.0}; double explosive_release_energy_values[2] = {0.0, 0.0}; double explosive_release_momentum_values[3] = {0.0, 0.0, 0.0}; + int solid_active_count = 0; + int solid_failed_count = 0; + double solid_values[SPHLITE_SOLID_SUMMARY_VALUE_COUNT] = {0.0}; if (SPHLITE_PHASE_SOLID != 4 || SPHLITE_PHASE_GAS != 2 || SPHLITE_STATUS_ACTIVE != 0) { @@ -138,10 +141,26 @@ int main(void) explosive_release_energy_values, NULL) != -1) { return fail("null explosive release momentum pointer did not return -1"); } + if (sphlite_get_solid_summary(NULL, &solid_failed_count, solid_values, + SPHLITE_SOLID_SUMMARY_VALUE_COUNT) != -1) { + return fail("null Solid active-count pointer did not return -1"); + } + if (sphlite_get_solid_summary(&solid_active_count, &solid_failed_count, NULL, + SPHLITE_SOLID_SUMMARY_VALUE_COUNT) != -1) { + return fail("null Solid summary values pointer did not return -1"); + } + if (sphlite_get_solid_summary(&solid_active_count, &solid_failed_count, + solid_values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT - 1) != -1) { + return fail("small Solid summary capacity did not return -1"); + } if (sphlite_get_gas_summary(&gas_volume, gas_center, &gas_mean_pressure, &gas_max_pressure) != 2) { return fail("uninitialized gas summary did not return Fortran state error"); } + if (sphlite_get_solid_summary(&solid_active_count, &solid_failed_count, + solid_values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT) != 2) { + return fail("uninitialized Solid summary did not return Fortran state error"); + } ierr = sphlite_initialize(); if (ierr != 0) return fail("initialize failed"); @@ -154,6 +173,9 @@ int main(void) if (ierr != 2) return fail("unbuilt gas summary did not return Fortran state error"); ierr = sphlite_get_gas_dt_limits(&dt_cfl, &dt_accel, &gas_dtcrit); if (ierr != 2) return fail("unbuilt gas dt did not return Fortran state error"); + ierr = sphlite_get_solid_summary(&solid_active_count, &solid_failed_count, + solid_values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT); + if (ierr != 2) return fail("unbuilt Solid summary did not return Fortran state error"); ierr = sphlite_get_version(&major, &minor, &patch); if (ierr != 0) return fail("get_version failed"); @@ -184,6 +206,17 @@ int main(void) return fail("particle state content mismatch"); } + ierr = sphlite_get_solid_summary(&solid_active_count, &solid_failed_count, + solid_values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT); + if (ierr != 0) return fail("Solid summary query failed"); + if (solid_active_count != 4 || solid_failed_count != 0 || + solid_values[0] <= 0.0) { + return fail("Solid summary content mismatch"); + } + if (solid_values[13] <= 0.0 || solid_values[15] <= 0.0) { + return fail("Solid dt summary content mismatch"); + } + if (sphlite_get_particle_state(4, NULL, phase, status, material_id, section_id, x, v, a, rho, pressure, internal_energy, temperature, h, &count) != -1) { return fail("null particle-state array did not return -1"); diff --git a/tests/interface/test_cpp_api.cpp b/tests/interface/test_cpp_api.cpp index 002b7b5..aa0c30b 100644 --- a/tests/interface/test_cpp_api.cpp +++ b/tests/interface/test_cpp_api.cpp @@ -29,6 +29,13 @@ int main() if (state.particle_id_ext.size() != 4 || state.phase[0] != sphlite::PhaseSolid) { return 1; } + sphlite::SolidSummary solid = sphlite::solid_summary(); + if (solid.active_count != 4 || solid.failed_count != 0 || solid.mass <= 0.0) { + return 1; + } + if (solid.dt_limits[0] <= 0.0 || solid.dt_limits[2] <= 0.0) { + return 1; + } } try { diff --git a/todo.md b/todo.md index d5bc372..497c681 100644 --- a/todo.md +++ b/todo.md @@ -177,28 +177,28 @@ ## 阶段 G:Fortran API、C ABI、C++、Python 与 CLI -- [ ] 新增 `sph_get_solid_summary` Fortran API。 -- [ ] 新增 Solid failure counts Fortran API。 -- [ ] 新增 Solid material summary Fortran API 或确认暂不对外暴露。 -- [ ] 为 Solid Fortran API 补齐未初始化错误路径。 -- [ ] 新增 `sphlite_get_solid_summary` C ABI。 -- [ ] 为 Solid C ABI 补齐空指针错误路径。 -- [ ] 为 Solid C ABI 补齐小容量或非法参数错误路径。 -- [ ] 在 C API 测试中覆盖 Solid summary 查询。 -- [ ] 在 C API 测试中覆盖 Solid API 错误路径。 -- [ ] 在 C++ wrapper 中增加 Solid summary 薄包装。 -- [ ] 在 C++ API 测试中覆盖 Solid summary 薄包装。 -- [ ] 在 Python ctypes 中增加 Solid summary 薄包装。 -- [ ] 在 Python inspect 中追加 Solid 字段。 -- [ ] 在 Python run/checker 中覆盖 Solid-only smoke。 -- [ ] 在 Python checker 中覆盖 Solid restart 读回 summary。 -- [ ] 在 CLI inspect 中追加 Solid 字段。 -- [ ] 在 CLI run 中追加 Solid 字段。 -- [ ] 在 CLI checker 中覆盖 Solid 输入、run 和 restart。 -- [ ] 确认新增 API 不改变 0.4.1 既有接口语义。 -- [ ] 新增 `solid_c_api` 测试并接入 CTest。 -- [ ] 新增 `solid_python` 测试并接入 CTest。 -- [ ] 新增 `solid_cli` 测试并接入 CTest。 +- [x] 新增 `sph_get_solid_summary` Fortran API。 +- [x] 新增 Solid failure counts Fortran API。 +- [x] 新增 Solid material summary Fortran API 或确认暂不对外暴露。 +- [x] 为 Solid Fortran API 补齐未初始化错误路径。 +- [x] 新增 `sphlite_get_solid_summary` C ABI。 +- [x] 为 Solid C ABI 补齐空指针错误路径。 +- [x] 为 Solid C ABI 补齐小容量或非法参数错误路径。 +- [x] 在 C API 测试中覆盖 Solid summary 查询。 +- [x] 在 C API 测试中覆盖 Solid API 错误路径。 +- [x] 在 C++ wrapper 中增加 Solid summary 薄包装。 +- [x] 在 C++ API 测试中覆盖 Solid summary 薄包装。 +- [x] 在 Python ctypes 中增加 Solid summary 薄包装。 +- [x] 在 Python inspect 中追加 Solid 字段。 +- [x] 在 Python run/checker 中覆盖 Solid-only smoke。 +- [x] 在 Python checker 中覆盖 Solid restart 读回 summary。 +- [x] 在 CLI inspect 中追加 Solid 字段。 +- [x] 在 CLI run 中追加 Solid 字段。 +- [x] 在 CLI checker 中覆盖 Solid 输入、run 和 restart。 +- [x] 确认新增 API 不改变 0.4.1 既有接口语义。 +- [x] 新增 `solid_c_api` 测试并接入 CTest。 +- [x] 新增 `solid_python` 测试并接入 CTest。 +- [x] 新增 `solid_cli` 测试并接入 CTest。 ## 阶段 H:回归、门禁、文档同步与发布准备 diff --git a/tools/testing/test_cli.py b/tools/testing/test_cli.py index b90f10a..4a3c6b6 100644 --- a/tools/testing/test_cli.py +++ b/tools/testing/test_cli.py @@ -99,6 +99,24 @@ def main() -> int: "explosive_release_momentum_x", "explosive_release_momentum_y", "explosive_release_momentum_z", + "solid_particles", + "solid_failed_particles", + "solid_mass", + "solid_momentum_x", + "solid_momentum_y", + "solid_momentum_z", + "solid_kinetic_energy", + "solid_internal_energy", + "solid_max_von_mises", + "solid_plastic_strain_min", + "solid_plastic_strain_max", + "solid_damage_min", + "solid_damage_max", + "solid_softening_min", + "solid_softening_max", + "solid_dt_cfl", + "solid_dt_accel", + "solid_dtcrit", "status", ): require_field(inspect.stdout, field) @@ -129,6 +147,8 @@ def main() -> int: raise AssertionError("CLI water inspect gas particle count mismatch") if int(inspect_fields["explosive_particles"]) != 0: raise AssertionError("CLI water inspect explosive particle count mismatch") + if int(inspect_fields["solid_particles"]) != 0: + raise AssertionError("CLI water inspect solid particle count mismatch") if inspect_fields["status"] != "ok": raise AssertionError("CLI status field mismatch") diff --git a/tools/testing/test_python_debug.py b/tools/testing/test_python_debug.py index a6032e9..6fa3852 100644 --- a/tools/testing/test_python_debug.py +++ b/tools/testing/test_python_debug.py @@ -37,6 +37,8 @@ def main() -> int: raise AssertionError("Python wrapper is missing Explosive release C ABI") if not hasattr(solver.lib, "sphlite_set_ignition_point"): raise AssertionError("Python wrapper is missing Explosive ignition C ABI") + if not hasattr(solver.lib, "sphlite_get_solid_summary"): + raise AssertionError("Python wrapper is missing Solid C ABI diagnostics") if solver.version() != (0, 5, 0): raise AssertionError("Python version mismatch") @@ -63,11 +65,18 @@ def main() -> int: raise AssertionError("inspect helper did not include Explosive diagnostics") if "explosive_release_mass_values" not in solid_summary: raise AssertionError("inspect helper did not include Explosive release balance") + if solid_summary["solid_particles"] != 4 or solid_summary["solid_mass"] <= 0.0: + raise AssertionError("inspect helper did not include Solid diagnostics") + if solid_summary["solid_dt_limits"][0] <= 0.0: + raise AssertionError("inspect helper did not include Solid dt diagnostics") solver.set_output_directory(root / "build-codex-unix") solver.write_output(0, 0.0) restart = root / "build-codex-unix" / "python_restart.tmp" solver.write_restart(restart) solver.read_restart(restart) + restart_summary = solver.solid_summary() + if restart_summary["solid_particles"] != 4: + raise AssertionError("Solid restart summary mismatch") solver.run_explicit() finally: solver.finalize() diff --git a/tools/testing/test_solid_cli.py b/tools/testing/test_solid_cli.py new file mode 100644 index 0000000..26c08c5 --- /dev/null +++ b/tools/testing/test_solid_cli.py @@ -0,0 +1,87 @@ +from __future__ import annotations + +import argparse +import subprocess +import sys +from pathlib import Path + + +def run_command(args: list[str]) -> subprocess.CompletedProcess[str]: + result = subprocess.run(args, text=True, capture_output=True) + if result.returncode != 0: + raise AssertionError(result.stderr or result.stdout) + return result + + +def read_fields(output: str) -> dict[str, str]: + fields: dict[str, str] = {} + for line in output.splitlines(): + if ":" in line: + name, value = line.split(":", 1) + fields[name.strip()] = value.strip() + return fields + + +def read_summary(path: Path) -> dict[str, str]: + result: dict[str, str] = {} + for line in path.read_text(encoding="utf-8").splitlines()[1:]: + if "," in line: + name, value = line.split(",", 1) + result[name.strip()] = value.strip() + return result + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--exe", required=True) + parser.add_argument("--library", required=True) + parser.add_argument("--input", required=True) + parser.add_argument("--output-dir", required=True) + args = parser.parse_args() + + root = Path(__file__).resolve().parents[2] + sys.path.insert(0, str(root / "Python")) + from sphlite_debug import SPHLite + + exe = str(Path(args.exe)) + model = str(Path(args.input)) + output_dir = Path(args.output_dir) + + inspect = read_fields(run_command([exe, model]).stdout) + if inspect["mode"] != "inspect" or inspect["status"] != "ok": + raise AssertionError("Solid CLI inspect mode mismatch") + if int(inspect["solid_particles"]) != 4: + raise AssertionError("Solid CLI inspect particle count mismatch") + if float(inspect["solid_mass"]) <= 0.0: + raise AssertionError("Solid CLI inspect mass mismatch") + if float(inspect["solid_dtcrit"]) <= 0.0: + raise AssertionError("Solid CLI inspect dt mismatch") + + run = read_fields(run_command([exe, model, "--run", "--output", str(output_dir)]).stdout) + if run["mode"] != "run" or int(run["step"]) <= 0: + raise AssertionError("Solid CLI run mode mismatch") + if int(run["solid_particles"]) != 4 or float(run["solid_mass"]) <= 0.0: + raise AssertionError("Solid CLI run summary mismatch") + summary_path = output_dir / f"sphlite_{int(run['step']):08d}_summary.csv" + summary = read_summary(summary_path) + if int(summary["solid_particles"]) != 4: + raise AssertionError("Solid CLI output summary mismatch") + + solver = SPHLite(args.library) + solver.initialize() + try: + solver.read_inp(model) + solver.build_model() + restart = output_dir / "solid_cli_restart.tmp" + solver.write_restart(restart) + solver.read_restart(restart) + solid = solver.solid_summary() + if solid["solid_particles"] != 4 or solid["solid_mass"] <= 0.0: + raise AssertionError("Solid CLI restart checker mismatch") + finally: + solver.finalize() + return 0 + + +if __name__ == "__main__": + raise SystemExit(main())