From 348f244693e3edd38307c0c12f2ef9f5b8eff14a Mon Sep 17 00:00:00 2001 From: Codex Date: Fri, 3 Jul 2026 18:26:41 +0800 Subject: [PATCH] Expose Solid 0.5.1 state APIs --- CMakeLists.txt | 27 ++++ Python/sphlite_debug.py | 81 ++++++++++- include/sphlite.hpp | 58 ++++++++ include/sphlite_c_api.h | 17 +++ src/app/sph_main.c | 25 ++++ src/interface/sph_api.f90 | 103 ++++++++++++- src/interface/sph_c_api.c | 60 ++++++++ src/solid/sph_solid_dynamics.f90 | 94 ++++++++++++ tests/interface/test_c_api.c | 83 +++++++++++ tests/interface/test_cpp_api.cpp | 19 +++ tests/module/test_solid_state_api.f90 | 200 ++++++++++++++++++++++++++ todo.md | 66 ++++----- tools/testing/test_cli.py | 6 + tools/testing/test_python_debug.py | 50 +++++++ tools/testing/test_solid_cli.py | 17 +++ 15 files changed, 871 insertions(+), 35 deletions(-) create mode 100644 tests/module/test_solid_state_api.f90 diff --git a/CMakeLists.txt b/CMakeLists.txt index 0856398..715a4d5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -59,6 +59,9 @@ if(CMAKE_Fortran_COMPILER_ID STREQUAL "GNU") #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_ +#define SPHLITE_FC_sphft_get_solid_state sphft_get_solid_state_ +#define SPHLITE_FC_sphft_get_solid_diagnostics sphft_get_solid_diagnostics_ +#define SPHLITE_FC_sphft_get_solid_reference_quality sphft_get_solid_reference_quality_ #endif ") endif() @@ -295,6 +298,12 @@ set_target_properties(test_solid_output PROPERTIES Fortran_MODULE_DIRECTORY "${S add_test(NAME solid_output COMMAND test_solid_output) set_tests_properties(solid_output PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_executable(test_solid_state_api tests/module/test_solid_state_api.f90) +target_link_libraries(test_solid_state_api PRIVATE sphlite_core) +set_target_properties(test_solid_state_api PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME solid_state_api COMMAND test_solid_state_api) +set_tests_properties(solid_state_api PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_executable(test_solid_restart_050 tests/module/test_solid_restart_050.f90) target_link_libraries(test_solid_restart_050 PRIVATE sphlite_core) set_target_properties(test_solid_restart_050 PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") @@ -629,6 +638,14 @@ add_test( --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 solid_python_051 + 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_051 PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") add_test( NAME cli @@ -684,6 +701,16 @@ add_test( --output-dir "${CMAKE_BINARY_DIR}" ) set_tests_properties(solid_cli PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_test( + NAME solid_cli_051 + 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_051 PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") add_test( NAME source_size diff --git a/Python/sphlite_debug.py b/Python/sphlite_debug.py index f15e9cb..dbfead7 100644 --- a/Python/sphlite_debug.py +++ b/Python/sphlite_debug.py @@ -128,6 +128,29 @@ class SPHLite: 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_solid_particle_state.argtypes = [ + ctypes.c_int, + ctypes.POINTER(ctypes.c_double), + ctypes.c_int, + ctypes.POINTER(ctypes.c_int), + ctypes.POINTER(ctypes.c_int), + ctypes.POINTER(ctypes.c_int), + ctypes.POINTER(ctypes.c_int), + ctypes.POINTER(ctypes.c_int), + ] + self.lib.sphlite_get_solid_particle_state.restype = ctypes.c_int + self.lib.sphlite_get_solid_diagnostics.argtypes = [ + ctypes.POINTER(ctypes.c_double), + ctypes.c_int, + ] + self.lib.sphlite_get_solid_diagnostics.restype = ctypes.c_int + self.lib.sphlite_get_solid_reference_quality.argtypes = [ + ctypes.POINTER(ctypes.c_int), + ctypes.POINTER(ctypes.c_int), + ctypes.POINTER(ctypes.c_double), + ctypes.c_int, + ] + self.lib.sphlite_get_solid_reference_quality.restype = ctypes.c_int self.lib.sphlite_get_particle_state.argtypes = [ ctypes.c_int, @@ -446,7 +469,7 @@ class SPHLite: self._check(self.lib.sphlite_get_solid_summary( ctypes.byref(active), ctypes.byref(failed), values, len(values))) v = list(values) - return { + summary = { "solid_particles": int(active.value), "solid_failed_particles": int(failed.value), "solid_mass": float(v[0]), @@ -459,6 +482,62 @@ class SPHLite: "solid_softening_range": v[11:13], "solid_dt_limits": v[13:16], } + summary.update(self.solid_diagnostics()) + summary.update(self.solid_reference_quality()) + return summary + + def solid_particle_state(self) -> dict[str, list[float] | list[int]]: + count = self.particle_count() + value_count = 22 + values = (ctypes.c_double * (value_count * count))() + int_array = ctypes.c_int * count + failure_status = int_array() + reference_neighbor_count = int_array() + reference_degenerate = int_array() + correction_status = int_array() + actual = ctypes.c_int(0) + self._check(self.lib.sphlite_get_solid_particle_state( + count, + values, + len(values), + failure_status, + reference_neighbor_count, + reference_degenerate, + correction_status, + ctypes.byref(actual), + )) + return { + "solid_values": list(values), + "solid_failure_status": list(failure_status), + "solid_reference_neighbor_count": list(reference_neighbor_count), + "solid_reference_degenerate": list(reference_degenerate), + "solid_correction_status": list(correction_status), + } + + def solid_diagnostics(self) -> dict[str, float]: + values = (ctypes.c_double * 3)() + self._check(self.lib.sphlite_get_solid_diagnostics(values, len(values))) + return { + "solid_max_strain_rate": float(values[0]), + "solid_max_acceleration": float(values[1]), + "solid_internal_force_residual": float(values[2]), + } + + def solid_reference_quality(self) -> dict[str, int | float]: + reference_neighbor_min = ctypes.c_int(0) + correction_status = ctypes.c_int(0) + values = (ctypes.c_double * 1)() + self._check(self.lib.sphlite_get_solid_reference_quality( + ctypes.byref(reference_neighbor_min), + ctypes.byref(correction_status), + values, + len(values), + )) + return { + "solid_reference_neighbor_min": int(reference_neighbor_min.value), + "solid_correction_det_min": float(values[0]), + "solid_correction_status": int(correction_status.value), + } def inspect(self, filename: str | Path) -> dict[str, int | float | list[float]]: self.read_inp(filename) diff --git a/include/sphlite.hpp b/include/sphlite.hpp index f47d640..c36f3ad 100644 --- a/include/sphlite.hpp +++ b/include/sphlite.hpp @@ -124,6 +124,26 @@ struct SolidSummary { double dt_limits[3]; }; +struct SolidParticleState { + std::vector values; + std::vector failure_status; + std::vector reference_neighbor_count; + std::vector reference_degenerate; + std::vector correction_status; +}; + +struct SolidDiagnostics { + double max_strain_rate; + double max_acceleration; + double internal_force_residual; +}; + +struct SolidReferenceQuality { + int reference_neighbor_min; + double correction_det_min; + int correction_status; +}; + class Error : public std::runtime_error { public: explicit Error(const std::string &message) : std::runtime_error(message) {} @@ -319,6 +339,44 @@ inline SolidSummary solid_summary() return summary; } +inline SolidParticleState solid_particle_state() +{ + int count = particle_count(); + SolidParticleState state; + state.values.resize(SPHLITE_SOLID_PARTICLE_VALUE_COUNT * count); + state.failure_status.resize(count); + state.reference_neighbor_count.resize(count); + state.reference_degenerate.resize(count); + state.correction_status.resize(count); + int actual = 0; + check(sphlite_get_solid_particle_state(count, state.values.data(), + static_cast(state.values.size()), state.failure_status.data(), + state.reference_neighbor_count.data(), state.reference_degenerate.data(), + state.correction_status.data(), &actual)); + return state; +} + +inline SolidDiagnostics solid_diagnostics() +{ + double values[SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT] = {0.0, 0.0, 0.0}; + check(sphlite_get_solid_diagnostics( + values, SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT)); + SolidDiagnostics diagnostics = {values[0], values[1], values[2]}; + return diagnostics; +} + +inline SolidReferenceQuality solid_reference_quality() +{ + int reference_neighbor_min = 0; + int correction_status = 0; + double values[SPHLITE_SOLID_REFERENCE_VALUE_COUNT] = {0.0}; + check(sphlite_get_solid_reference_quality(&reference_neighbor_min, + &correction_status, values, SPHLITE_SOLID_REFERENCE_VALUE_COUNT)); + SolidReferenceQuality quality = { + reference_neighbor_min, values[0], correction_status}; + return quality; +} + 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 225d8c0..d1e4d33 100644 --- a/include/sphlite_c_api.h +++ b/include/sphlite_c_api.h @@ -31,6 +31,9 @@ extern "C" { #define SPHLITE_STATUS_RESERVED 3 #define SPHLITE_SOLID_SUMMARY_VALUE_COUNT 16 +#define SPHLITE_SOLID_PARTICLE_VALUE_COUNT 22 +#define SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT 3 +#define SPHLITE_SOLID_REFERENCE_VALUE_COUNT 1 SPHLITE_API int sphlite_initialize(void); SPHLITE_API int sphlite_finalize(void); @@ -103,6 +106,20 @@ SPHLITE_API int sphlite_get_solid_summary(int *active_count, int *failed_count, double *values, int value_capacity); +SPHLITE_API int sphlite_get_solid_particle_state(int max_particles, + double *values, + int value_capacity, + int *failure_status, + int *reference_neighbor_count, + int *reference_degenerate, + int *correction_status, + int *count); +SPHLITE_API int sphlite_get_solid_diagnostics(double *values, + int value_capacity); +SPHLITE_API int sphlite_get_solid_reference_quality(int *reference_neighbor_min, + int *correction_status, + double *values, + int value_capacity); #ifdef __cplusplus } diff --git a/src/app/sph_main.c b/src/app/sph_main.c index d8bf96a..0eaaeb0 100644 --- a/src/app/sph_main.c +++ b/src/app/sph_main.c @@ -141,6 +141,10 @@ int main(int argc, char **argv) int solid_particles = 0; int solid_failed_particles = 0; double solid_values[SPHLITE_SOLID_SUMMARY_VALUE_COUNT] = {0.0}; + double solid_diagnostics[SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT] = {0.0}; + double solid_reference_values[SPHLITE_SOLID_REFERENCE_VALUE_COUNT] = {0.0}; + int solid_reference_neighbor_min = 0; + int solid_correction_status = 0; int run_mode = 0; int check_mode = 0; const char *input = NULL; @@ -346,6 +350,21 @@ int main(int argc, char **argv) (void)sphlite_finalize(); return 1; } + ierr = sphlite_get_solid_diagnostics(solid_diagnostics, + SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT); + if (ierr != 0) { + sphlite_print_error(); + (void)sphlite_finalize(); + return 1; + } + ierr = sphlite_get_solid_reference_quality(&solid_reference_neighbor_min, + &solid_correction_status, solid_reference_values, + SPHLITE_SOLID_REFERENCE_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); @@ -416,6 +435,12 @@ int main(int argc, char **argv) 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_max_strain_rate: %.16e\n", solid_diagnostics[0]); + printf("solid_max_acceleration: %.16e\n", solid_diagnostics[1]); + printf("solid_internal_force_residual: %.16e\n", solid_diagnostics[2]); + printf("solid_reference_neighbor_min: %d\n", solid_reference_neighbor_min); + printf("solid_correction_det_min: %.16e\n", solid_reference_values[0]); + printf("solid_correction_status: %d\n", solid_correction_status); 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]); diff --git a/src/interface/sph_api.f90 b/src/interface/sph_api.f90 index 8745448..4bdd69b 100644 --- a/src/interface/sph_api.f90 +++ b/src/interface/sph_api.f90 @@ -28,7 +28,9 @@ 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_solid_dynamics, only: sph_solid_get_counts, sph_solid_get_summary, & + sph_solid_get_state, sph_solid_get_diagnostics, & + sph_solid_get_reference_quality 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 @@ -545,6 +547,59 @@ contains dt_limits, ierr) end subroutine sph_get_solid_summary + subroutine sph_get_solid_state(max_particles, value_capacity, values, & + failure_status, reference_neighbor_count, reference_degenerate, & + correction_status, count, ierr) + integer, intent(in) :: max_particles + integer, intent(in) :: value_capacity + real(rk), intent(out) :: values(value_capacity,max_particles) + integer, intent(out) :: failure_status(max_particles) + integer, intent(out) :: reference_neighbor_count(max_particles) + integer, intent(out) :: reference_degenerate(max_particles) + integer, intent(out) :: correction_status(max_particles) + integer, intent(out) :: count + integer, intent(out) :: ierr + + 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_state(max_particles, value_capacity, values, & + failure_status, reference_neighbor_count, reference_degenerate, & + correction_status, count, ierr) + end subroutine sph_get_solid_state + + subroutine sph_get_solid_diagnostics(value_capacity, values, ierr) + integer, intent(in) :: value_capacity + real(rk), intent(out) :: values(value_capacity) + integer, intent(out) :: ierr + + 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_diagnostics(value_capacity, values, ierr) + end subroutine sph_get_solid_diagnostics + + subroutine sph_get_solid_reference_quality(reference_neighbor_min, & + correction_det_min, correction_status, ierr) + integer, intent(out) :: reference_neighbor_min + real(rk), intent(out) :: correction_det_min + integer, intent(out) :: correction_status + integer, intent(out) :: ierr + + reference_neighbor_min = 0 + correction_det_min = 0.0_rk + correction_status = 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_reference_quality(reference_neighbor_min, & + correction_det_min, correction_status, ierr) + end subroutine sph_get_solid_reference_quality + subroutine sph_api_require_initialized(ierr) integer, intent(out) :: ierr @@ -902,6 +957,52 @@ subroutine sphft_get_solid_summary(active_count, failed_count, mass, momentum, & dt_limits, ierr) end subroutine sphft_get_solid_summary +subroutine sphft_get_solid_state(max_particles, value_capacity, values, & + failure_status, reference_neighbor_count, reference_degenerate, & + correction_status, count, ierr) + use sph_api, only: sph_get_solid_state + use sph_precision, only: rk + implicit none + integer, intent(in) :: max_particles + integer, intent(in) :: value_capacity + real(rk), intent(out) :: values(value_capacity,max_particles) + integer, intent(out) :: failure_status(max_particles) + integer, intent(out) :: reference_neighbor_count(max_particles) + integer, intent(out) :: reference_degenerate(max_particles) + integer, intent(out) :: correction_status(max_particles) + integer, intent(out) :: count + integer, intent(out) :: ierr + + call sph_get_solid_state(max_particles, value_capacity, values, & + failure_status, reference_neighbor_count, reference_degenerate, & + correction_status, count, ierr) +end subroutine sphft_get_solid_state + +subroutine sphft_get_solid_diagnostics(value_capacity, values, ierr) + use sph_api, only: sph_get_solid_diagnostics + use sph_precision, only: rk + implicit none + integer, intent(in) :: value_capacity + real(rk), intent(out) :: values(value_capacity) + integer, intent(out) :: ierr + + call sph_get_solid_diagnostics(value_capacity, values, ierr) +end subroutine sphft_get_solid_diagnostics + +subroutine sphft_get_solid_reference_quality(reference_neighbor_min, & + correction_det_min, correction_status, ierr) + use sph_api, only: sph_get_solid_reference_quality + use sph_precision, only: rk + implicit none + integer, intent(out) :: reference_neighbor_min + real(rk), intent(out) :: correction_det_min + integer, intent(out) :: correction_status + integer, intent(out) :: ierr + + call sph_get_solid_reference_quality(reference_neighbor_min, & + correction_det_min, correction_status, ierr) +end subroutine sphft_get_solid_reference_quality + 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 f82148b..8f903b4 100644 --- a/src/interface/sph_c_api.c +++ b/src/interface/sph_c_api.c @@ -105,6 +105,15 @@ 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); +extern void SPHLITE_FC_sphft_get_solid_state(const int *max_particles, + const int *value_capacity, double *values, int *failure_status, + int *reference_neighbor_count, int *reference_degenerate, + int *correction_status, int *count, int *ierr); +extern void SPHLITE_FC_sphft_get_solid_diagnostics( + const int *value_capacity, double *values, int *ierr); +extern void SPHLITE_FC_sphft_get_solid_reference_quality( + int *reference_neighbor_min, double *correction_det_min, + int *correction_status, int *ierr); static int sphlite_call_path( const char *path, @@ -498,3 +507,54 @@ int sphlite_get_solid_summary(int *active_count, int *failed_count, } return ierr; } + +int sphlite_get_solid_particle_state(int max_particles, + double *values, + int value_capacity, + int *failure_status, + int *reference_neighbor_count, + int *reference_degenerate, + int *correction_status, + int *count) +{ + int ierr = 0; + int per_particle = SPHLITE_SOLID_PARTICLE_VALUE_COUNT; + + if (max_particles <= 0 || values == NULL || failure_status == NULL || + reference_neighbor_count == NULL || reference_degenerate == NULL || + correction_status == NULL || count == NULL || + value_capacity < max_particles * SPHLITE_SOLID_PARTICLE_VALUE_COUNT) { + return -1; + } + SPHLITE_FC_sphft_get_solid_state(&max_particles, &per_particle, values, + failure_status, reference_neighbor_count, reference_degenerate, + correction_status, count, &ierr); + return ierr; +} + +int sphlite_get_solid_diagnostics(double *values, int value_capacity) +{ + int ierr = 0; + + if (values == NULL || value_capacity < SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT) { + return -1; + } + SPHLITE_FC_sphft_get_solid_diagnostics(&value_capacity, values, &ierr); + return ierr; +} + +int sphlite_get_solid_reference_quality(int *reference_neighbor_min, + int *correction_status, + double *values, + int value_capacity) +{ + int ierr = 0; + + if (reference_neighbor_min == NULL || correction_status == NULL || + values == NULL || value_capacity < SPHLITE_SOLID_REFERENCE_VALUE_COUNT) { + return -1; + } + SPHLITE_FC_sphft_get_solid_reference_quality(reference_neighbor_min, + &values[0], correction_status, &ierr); + return ierr; +} diff --git a/src/solid/sph_solid_dynamics.f90 b/src/solid/sph_solid_dynamics.f90 index 9a59ba9..9b0a0be 100644 --- a/src/solid/sph_solid_dynamics.f90 +++ b/src/solid/sph_solid_dynamics.f90 @@ -21,6 +21,9 @@ module sph_solid_dynamics use sph_solid_material, only: sph_solid_von_mises implicit none + integer, parameter :: SPH_SOLID_STATE_VALUE_COUNT = 22 + integer, parameter :: SPH_SOLID_DIAGNOSTIC_VALUE_COUNT = 3 + contains subroutine sph_solid_set_body_force(force, ierr) @@ -86,6 +89,97 @@ contains softening_range_out = (/solid_min_softening, solid_max_softening/) end subroutine sph_solid_get_summary + subroutine sph_solid_get_state(max_particles, value_capacity, values, & + failure_status_out, reference_neighbor_count_out, & + reference_degenerate_out, correction_status_out, count, ierr) + integer, intent(in) :: max_particles + integer, intent(in) :: value_capacity + real(rk), intent(out) :: values(value_capacity,max_particles) + integer, intent(out) :: failure_status_out(max_particles) + integer, intent(out) :: reference_neighbor_count_out(max_particles) + integer, intent(out) :: reference_degenerate_out(max_particles) + integer, intent(out) :: correction_status_out(max_particles) + integer, intent(out) :: count + integer, intent(out) :: ierr + integer :: i + + count = 0 + ierr = SPH_SUCCESS + if (max_particles <= 0 .or. value_capacity < SPH_SOLID_STATE_VALUE_COUNT) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid state buffer is too small') + ierr = SPH_ERROR_ARGUMENT + return + end if + values = 0.0_rk + failure_status_out = 0 + reference_neighbor_count_out = 0 + reference_degenerate_out = 0 + correction_status_out = 0 + if (npart > max_particles) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid state particle buffer is too small') + ierr = SPH_ERROR_ARGUMENT + return + end if + count = npart + if (.not. allocated(solid_stress)) return + do i = 1, npart + values(1:6,i) = solid_stress(:,i) + values(7:12,i) = solid_strain(:,i) + if (allocated(solid_strain_rate)) values(13:18,i) = solid_strain_rate(:,i) + if (allocated(solid_plastic_strain)) values(19,i) = solid_plastic_strain(i) + if (allocated(solid_damage)) values(20,i) = solid_damage(i) + if (allocated(solid_softening)) values(21,i) = solid_softening(i) + if (allocated(solid_strain_rate_eq)) values(22,i) = solid_strain_rate_eq(i) + if (allocated(solid_failure_status)) failure_status_out(i) = & + solid_failure_status(i) + if (allocated(solid_reference_neighbor_count)) then + reference_neighbor_count_out(i) = solid_reference_neighbor_count(i) + end if + if (allocated(solid_reference_degenerate)) then + reference_degenerate_out(i) = solid_reference_degenerate(i) + end if + if (allocated(solid_correction_status)) then + correction_status_out(i) = solid_correction_status(i) + end if + end do + end subroutine sph_solid_get_state + + subroutine sph_solid_get_diagnostics(value_capacity, values, ierr) + integer, intent(in) :: value_capacity + real(rk), intent(out) :: values(value_capacity) + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + if (value_capacity < SPH_SOLID_DIAGNOSTIC_VALUE_COUNT) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Solid diagnostic buffer is too small') + ierr = SPH_ERROR_ARGUMENT + return + end if + values = 0.0_rk + call sph_solid_update_diagnostics(ierr) + if (ierr /= SPH_SUCCESS) return + values(1) = solid_max_strain_rate + values(2) = solid_max_acceleration + values(3) = solid_internal_force_residual + end subroutine sph_solid_get_diagnostics + + subroutine sph_solid_get_reference_quality(reference_neighbor_min_out, & + correction_det_min_out, correction_status_out, ierr) + integer, intent(out) :: reference_neighbor_min_out + real(rk), intent(out) :: correction_det_min_out + integer, intent(out) :: correction_status_out + integer, intent(out) :: ierr + + reference_neighbor_min_out = 0 + correction_det_min_out = 0.0_rk + correction_status_out = 0 + call sph_solid_update_diagnostics(ierr) + if (ierr /= SPH_SUCCESS) return + reference_neighbor_min_out = solid_reference_neighbor_min + correction_det_min_out = solid_correction_det_min + correction_status_out = solid_correction_status_max + end subroutine sph_solid_get_reference_quality + subroutine sph_solid_build_reference_state(ierr) integer, intent(out) :: ierr integer :: i diff --git a/tests/interface/test_c_api.c b/tests/interface/test_c_api.c index 083a966..b2fef3b 100644 --- a/tests/interface/test_c_api.c +++ b/tests/interface/test_c_api.c @@ -66,6 +66,16 @@ int main(void) int solid_active_count = 0; int solid_failed_count = 0; double solid_values[SPHLITE_SOLID_SUMMARY_VALUE_COUNT] = {0.0}; + double solid_particle_values[4 * SPHLITE_SOLID_PARTICLE_VALUE_COUNT] = {0.0}; + int solid_failure_status[4] = {0}; + int solid_reference_neighbor_count[4] = {0}; + int solid_reference_degenerate[4] = {0}; + int solid_correction_status[4] = {0}; + int solid_state_count = 0; + double solid_diagnostics[SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT] = {0.0}; + double solid_reference_values[SPHLITE_SOLID_REFERENCE_VALUE_COUNT] = {0.0}; + int solid_reference_neighbor_min = 0; + int solid_correction_status_max = 0; if (SPHLITE_PHASE_SOLID != 4 || SPHLITE_PHASE_GAS != 2 || SPHLITE_STATUS_ACTIVE != 0) { @@ -153,6 +163,40 @@ int main(void) solid_values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT - 1) != -1) { return fail("small Solid summary capacity did not return -1"); } + if (sphlite_get_solid_particle_state(4, NULL, + 4 * SPHLITE_SOLID_PARTICLE_VALUE_COUNT, solid_failure_status, + solid_reference_neighbor_count, solid_reference_degenerate, + solid_correction_status, &solid_state_count) != -1) { + return fail("null Solid state values did not return -1"); + } + if (sphlite_get_solid_particle_state(4, solid_particle_values, + SPHLITE_SOLID_PARTICLE_VALUE_COUNT - 1, solid_failure_status, + solid_reference_neighbor_count, solid_reference_degenerate, + solid_correction_status, &solid_state_count) != -1) { + return fail("small Solid state capacity did not return -1"); + } + if (sphlite_get_solid_particle_state(4, solid_particle_values, + 4 * SPHLITE_SOLID_PARTICLE_VALUE_COUNT, NULL, + solid_reference_neighbor_count, solid_reference_degenerate, + solid_correction_status, &solid_state_count) != -1) { + return fail("null Solid failure status did not return -1"); + } + if (sphlite_get_solid_diagnostics(NULL, + SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT) != -1) { + return fail("null Solid diagnostics did not return -1"); + } + if (sphlite_get_solid_diagnostics(solid_diagnostics, + SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT - 1) != -1) { + return fail("small Solid diagnostics capacity did not return -1"); + } + if (sphlite_get_solid_reference_quality(NULL, &solid_correction_status_max, + solid_reference_values, SPHLITE_SOLID_REFERENCE_VALUE_COUNT) != -1) { + return fail("null Solid reference min did not return -1"); + } + if (sphlite_get_solid_reference_quality(&solid_reference_neighbor_min, + &solid_correction_status_max, solid_reference_values, 0) != -1) { + return fail("small Solid reference 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"); @@ -161,6 +205,16 @@ int main(void) solid_values, SPHLITE_SOLID_SUMMARY_VALUE_COUNT) != 2) { return fail("uninitialized Solid summary did not return Fortran state error"); } + if (sphlite_get_solid_particle_state(4, solid_particle_values, + 4 * SPHLITE_SOLID_PARTICLE_VALUE_COUNT, solid_failure_status, + solid_reference_neighbor_count, solid_reference_degenerate, + solid_correction_status, &solid_state_count) != 2) { + return fail("uninitialized Solid state did not return Fortran state error"); + } + if (sphlite_get_solid_diagnostics(solid_diagnostics, + SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT) != 2) { + return fail("uninitialized Solid diagnostics did not return state error"); + } ierr = sphlite_initialize(); if (ierr != 0) return fail("initialize failed"); @@ -176,6 +230,11 @@ int main(void) 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_solid_particle_state(4, solid_particle_values, + 4 * SPHLITE_SOLID_PARTICLE_VALUE_COUNT, solid_failure_status, + solid_reference_neighbor_count, solid_reference_degenerate, + solid_correction_status, &solid_state_count); + if (ierr != 2) return fail("unbuilt Solid state did not return Fortran state error"); ierr = sphlite_get_version(&major, &minor, &patch); if (ierr != 0) return fail("get_version failed"); @@ -216,6 +275,30 @@ int main(void) if (solid_values[13] <= 0.0 || solid_values[15] <= 0.0) { return fail("Solid dt summary content mismatch"); } + ierr = sphlite_get_solid_particle_state(4, solid_particle_values, + 4 * SPHLITE_SOLID_PARTICLE_VALUE_COUNT, solid_failure_status, + solid_reference_neighbor_count, solid_reference_degenerate, + solid_correction_status, &solid_state_count); + if (ierr != 0 || solid_state_count != 4) return fail("Solid state query failed"); + if (solid_failure_status[0] != SPHLITE_STATUS_ACTIVE || + solid_reference_neighbor_count[0] < 0 || + solid_correction_status[0] < 0) { + return fail("Solid state content mismatch"); + } + ierr = sphlite_get_solid_diagnostics(solid_diagnostics, + SPHLITE_SOLID_DIAGNOSTIC_VALUE_COUNT); + if (ierr != 0) return fail("Solid diagnostics query failed"); + if (solid_diagnostics[0] < 0.0 || solid_diagnostics[1] < 0.0 || + solid_diagnostics[2] < 0.0) { + return fail("Solid diagnostics content mismatch"); + } + ierr = sphlite_get_solid_reference_quality(&solid_reference_neighbor_min, + &solid_correction_status_max, solid_reference_values, + SPHLITE_SOLID_REFERENCE_VALUE_COUNT); + if (ierr != 0) return fail("Solid reference quality query failed"); + if (solid_reference_neighbor_min < 0 || solid_correction_status_max < 0) { + return fail("Solid reference quality 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) { diff --git a/tests/interface/test_cpp_api.cpp b/tests/interface/test_cpp_api.cpp index 1ccf319..9f328fa 100644 --- a/tests/interface/test_cpp_api.cpp +++ b/tests/interface/test_cpp_api.cpp @@ -36,6 +36,25 @@ int main() if (solid.dt_limits[0] <= 0.0 || solid.dt_limits[2] <= 0.0) { return 1; } + sphlite::SolidParticleState solid_state = sphlite::solid_particle_state(); + if (solid_state.values.size() != + SPHLITE_SOLID_PARTICLE_VALUE_COUNT * state.particle_id_ext.size()) { + return 1; + } + if (solid_state.failure_status[0] != sphlite::StatusActive || + solid_state.reference_neighbor_count[0] < 0 || + solid_state.correction_status[0] < 0) { + return 1; + } + sphlite::SolidDiagnostics solid_diag = sphlite::solid_diagnostics(); + if (solid_diag.max_strain_rate < 0.0 || solid_diag.max_acceleration < 0.0 || + solid_diag.internal_force_residual < 0.0) { + return 1; + } + sphlite::SolidReferenceQuality quality = sphlite::solid_reference_quality(); + if (quality.reference_neighbor_min < 0 || quality.correction_status < 0) { + return 1; + } } try { diff --git a/tests/module/test_solid_state_api.f90 b/tests/module/test_solid_state_api.f90 new file mode 100644 index 0000000..74d2a2e --- /dev/null +++ b/tests/module/test_solid_state_api.f90 @@ -0,0 +1,200 @@ +program test_solid_state_api + use sph_precision, only: rk + use sph_error, only: SPH_SUCCESS, SPH_ERROR_ARGUMENT, SPH_ERROR_STATE + use sph_api, only: sph_initialize, sph_finalize, sph_read_inp, sph_build_model, & + sph_get_solid_state, sph_get_solid_diagnostics, & + sph_get_solid_reference_quality + use sph_database, only: npart, a + use sph_solid_state, only: solid_stress, solid_strain, solid_strain_rate, & + solid_plastic_strain, solid_damage, solid_softening, solid_strain_rate_eq, & + solid_acc_internal, solid_reference_neighbor_count, & + solid_reference_degenerate, solid_correction_determinant, & + solid_correction_status, solid_failure_status + implicit none + + integer, parameter :: SOLID_STATE_VALUES = 22 + integer, parameter :: SOLID_DIAGNOSTICS = 3 + integer :: ierr + + call check_uninitialized_errors() + call check_unbuilt_errors() + call check_solid_state_values() + +contains + + subroutine check_uninitialized_errors() + real(rk) :: values(SOLID_STATE_VALUES,1) + integer :: failure(1) + integer :: ref_count(1) + integer :: ref_degenerate(1) + integer :: corr_status(1) + integer :: count + + call sph_get_solid_state(1, SOLID_STATE_VALUES, values, failure, ref_count, & + ref_degenerate, corr_status, count, ierr) + if (ierr /= SPH_ERROR_STATE) call fail('uninitialized Solid state API mismatch') + end subroutine check_uninitialized_errors + + subroutine check_unbuilt_errors() + real(rk) :: values(SOLID_STATE_VALUES,1) + real(rk) :: diagnostics(SOLID_DIAGNOSTICS) + integer :: failure(1) + integer :: ref_count(1) + integer :: ref_degenerate(1) + integer :: corr_status(1) + integer :: count + integer :: reference_neighbor_min + integer :: correction_status_value + real(rk) :: correction_det_min + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for Solid state API') + call sph_get_solid_state(1, SOLID_STATE_VALUES, values, failure, ref_count, & + ref_degenerate, corr_status, count, ierr) + if (ierr /= SPH_ERROR_STATE) call fail('unbuilt Solid state API mismatch') + call sph_get_solid_diagnostics(SOLID_DIAGNOSTICS, diagnostics, ierr) + if (ierr /= SPH_ERROR_STATE) call fail('unbuilt Solid diagnostics API mismatch') + call sph_get_solid_reference_quality(reference_neighbor_min, & + correction_det_min, correction_status_value, ierr) + if (ierr /= SPH_ERROR_STATE) call fail('unbuilt Solid reference API mismatch') + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for Solid state API') + end subroutine check_unbuilt_errors + + subroutine check_solid_state_values() + real(rk) :: values(SOLID_STATE_VALUES,4) + real(rk) :: bad_values(SOLID_STATE_VALUES - 1,4) + real(rk) :: small_particle_values(SOLID_STATE_VALUES,3) + real(rk) :: diagnostics(SOLID_DIAGNOSTICS) + real(rk) :: bad_diagnostics(SOLID_DIAGNOSTICS - 1) + integer :: failure(4) + integer :: ref_count(4) + integer :: ref_degenerate(4) + integer :: corr_status(4) + integer :: small_failure(3) + integer :: small_ref_count(3) + integer :: small_ref_degenerate(3) + integer :: small_corr_status(3) + integer :: count + integer :: reference_neighbor_min + integer :: correction_status_value + real(rk) :: correction_det_min + + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for Solid state values') + call sph_read_inp('tests/data/solid_elastic_minimal_050.inp', ierr) + call assert_ok(ierr, 'read failed for Solid state values') + call sph_build_model(ierr) + call assert_ok(ierr, 'build failed for Solid state values') + call seed_state_values() + call sph_get_solid_state(4, SOLID_STATE_VALUES - 1, bad_values, failure, & + ref_count, ref_degenerate, corr_status, count, ierr) + if (ierr /= SPH_ERROR_ARGUMENT) call fail('Solid state value capacity mismatch') + call sph_get_solid_state(3, SOLID_STATE_VALUES, small_particle_values, & + small_failure, small_ref_count, small_ref_degenerate, & + small_corr_status, count, ierr) + if (ierr /= SPH_ERROR_ARGUMENT) call fail('Solid state particle capacity mismatch') + call sph_get_solid_diagnostics(SOLID_DIAGNOSTICS - 1, bad_diagnostics, ierr) + if (ierr /= SPH_ERROR_ARGUMENT) call fail('Solid diagnostic capacity mismatch') + call sph_get_solid_state(4, SOLID_STATE_VALUES, values, failure, ref_count, & + ref_degenerate, corr_status, count, ierr) + call assert_ok(ierr, 'Solid state query failed') + if (count /= npart) call fail('Solid state count mismatch') + call assert_state_layout(values, failure, ref_count, ref_degenerate, corr_status) + call sph_get_solid_diagnostics(SOLID_DIAGNOSTICS, diagnostics, ierr) + call assert_ok(ierr, 'Solid diagnostics query failed') + if (abs(diagnostics(1) - 2.5_rk) > 1.0e-12_rk) then + call fail('Solid max strain rate diagnostic mismatch') + end if + if (abs(diagnostics(2) - 3.0_rk) > 1.0e-12_rk) then + call fail('Solid max acceleration diagnostic mismatch') + end if + call sph_get_solid_reference_quality(reference_neighbor_min, & + correction_det_min, correction_status_value, ierr) + call assert_ok(ierr, 'Solid reference quality query failed') + if (reference_neighbor_min /= 4) call fail('Solid reference min mismatch') + if (abs(correction_det_min - 0.25_rk) > 1.0e-12_rk) then + call fail('Solid correction determinant mismatch') + end if + if (correction_status_value /= 2) call fail('Solid correction status mismatch') + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for Solid state values') + end subroutine check_solid_state_values + + subroutine seed_state_values() + solid_stress(:,1) = (/1.0_rk, 2.0_rk, 3.0_rk, 4.0_rk, 5.0_rk, 6.0_rk/) + solid_strain(:,1) = (/0.1_rk, 0.2_rk, 0.3_rk, 0.4_rk, 0.5_rk, 0.6_rk/) + solid_strain_rate(:,1) = (/10.0_rk, 20.0_rk, 30.0_rk, & + 40.0_rk, 50.0_rk, 60.0_rk/) + solid_plastic_strain(1) = 0.7_rk + solid_damage(1) = 0.8_rk + solid_softening(1) = 0.9_rk + solid_strain_rate_eq = 0.0_rk + solid_strain_rate_eq(1) = 2.5_rk + solid_acc_internal = 0.0_rk + solid_acc_internal(1,1) = 1.0_rk + a = 0.0_rk + a(:,1) = (/1.0_rk, 2.0_rk, 2.0_rk/) + solid_reference_neighbor_count = 4 + solid_reference_degenerate = 0 + solid_correction_determinant = 0.50_rk + solid_correction_determinant(1) = 0.25_rk + solid_correction_status = 1 + solid_correction_status(1) = 2 + solid_failure_status = 0 + solid_failure_status(1) = 2 + end subroutine seed_state_values + + subroutine assert_state_layout(values, failure, ref_count, ref_degenerate, & + corr_status) + real(rk), intent(in) :: values(SOLID_STATE_VALUES,4) + integer, intent(in) :: failure(4) + integer, intent(in) :: ref_count(4) + integer, intent(in) :: ref_degenerate(4) + integer, intent(in) :: corr_status(4) + + if (maxval(abs(values(1:6,1) - (/1.0_rk, 2.0_rk, 3.0_rk, & + 4.0_rk, 5.0_rk, 6.0_rk/))) > 1.0e-12_rk) then + call fail('Solid stress layout mismatch') + end if + if (maxval(abs(values(7:12,1) - (/0.1_rk, 0.2_rk, 0.3_rk, & + 0.4_rk, 0.5_rk, 0.6_rk/))) > 1.0e-12_rk) then + call fail('Solid strain layout mismatch') + end if + if (maxval(abs(values(13:18,1) - (/10.0_rk, 20.0_rk, 30.0_rk, & + 40.0_rk, 50.0_rk, 60.0_rk/))) > 1.0e-12_rk) then + call fail('Solid strain-rate layout mismatch') + end if + if (abs(values(19,1) - 0.7_rk) > 1.0e-12_rk) then + call fail('Solid plastic state layout mismatch') + end if + if (abs(values(20,1) - 0.8_rk) > 1.0e-12_rk) then + call fail('Solid damage state layout mismatch') + end if + if (abs(values(21,1) - 0.9_rk) > 1.0e-12_rk) then + call fail('Solid softening state layout mismatch') + end if + if (abs(values(22,1) - 2.5_rk) > 1.0e-12_rk) then + call fail('Solid equivalent strain-rate layout mismatch') + end if + if (failure(1) /= 2) call fail('Solid failure status API mismatch') + if (ref_count(1) /= 4) call fail('Solid reference count API mismatch') + if (ref_degenerate(1) /= 0) call fail('Solid reference degenerate API mismatch') + if (corr_status(1) /= 2) call fail('Solid correction status API mismatch') + end subroutine assert_state_layout + + 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_state_api diff --git a/todo.md b/todo.md index fd4d2de..f549d99 100644 --- a/todo.md +++ b/todo.md @@ -215,39 +215,39 @@ ## 阶段 H:Fortran API、C ABI、C++、Python 与 CLI -- [ ] 新增 `sph_get_solid_state` Fortran API。 -- [ ] 新增 `sph_get_solid_diagnostics` Fortran API。 -- [ ] 新增 `sph_get_solid_reference_quality` Fortran API。 -- [ ] 为 Solid 0.5.1 Fortran API 补齐未初始化错误路径。 -- [ ] 为 Solid 0.5.1 Fortran API 补齐小容量错误路径。 -- [ ] 在 C 头文件中声明 `sphlite_get_solid_particle_state`。 -- [ ] 在 C ABI 中实现 Solid 粒子级状态查询。 -- [ ] 在 C ABI 中校验空指针错误路径。 -- [ ] 在 C ABI 中校验非正容量错误路径。 -- [ ] 在 C ABI 中校验小容量错误路径。 -- [ ] 在 C ABI 中锁定 stress 展开顺序。 -- [ ] 在 C ABI 中锁定 strain 展开顺序。 -- [ ] 在 C ABI 中锁定 strain-rate 展开顺序。 -- [ ] 在 C API 测试中覆盖 Solid 粒子级状态查询。 -- [ ] 在 C API 测试中覆盖 Solid 0.5.1 错误路径。 -- [ ] 在 C++ wrapper 中新增 Solid particle state 薄包装。 -- [ ] 在 C++ API 测试中覆盖 Solid particle state 薄包装。 -- [ ] 在 Python ctypes 中新增 Solid particle state 薄包装。 -- [ ] 在 Python inspect 中追加 Solid 0.5.1 诊断字段。 -- [ ] 在 Python run/checker 中覆盖 Solid 0.5.1 小模型。 -- [ ] 在 Python checker 中覆盖 `STATE_0_5_1` restart 读回。 -- [ ] 在 Python checker 中覆盖 `STATE_0_5` restart 兼容读入。 -- [ ] 在 CLI inspect 中追加 `solid_max_strain_rate` 字段。 -- [ ] 在 CLI inspect 中追加 `solid_max_acceleration` 字段。 -- [ ] 在 CLI inspect 中追加 `solid_internal_force_residual` 字段。 -- [ ] 在 CLI inspect 中追加 `solid_correction_status` 字段。 -- [ ] 在 CLI inspect 中追加 `solid_reference_neighbor_min` 字段。 -- [ ] 在 CLI run 中追加 Solid 0.5.1 诊断字段。 -- [ ] 在 CLI checker 中覆盖 Solid 0.5.1 输入、run 和 restart。 -- [ ] 确认新增 API 不改变 0.5.0 已有接口语义。 -- [ ] 新增 `solid_state_api` 测试并接入 CTest。 -- [ ] 新增 `solid_python_051` 测试并接入 CTest。 -- [ ] 新增 `solid_cli_051` 测试并接入 CTest。 +- [x] 新增 `sph_get_solid_state` Fortran API。 +- [x] 新增 `sph_get_solid_diagnostics` Fortran API。 +- [x] 新增 `sph_get_solid_reference_quality` Fortran API。 +- [x] 为 Solid 0.5.1 Fortran API 补齐未初始化错误路径。 +- [x] 为 Solid 0.5.1 Fortran API 补齐小容量错误路径。 +- [x] 在 C 头文件中声明 `sphlite_get_solid_particle_state`。 +- [x] 在 C ABI 中实现 Solid 粒子级状态查询。 +- [x] 在 C ABI 中校验空指针错误路径。 +- [x] 在 C ABI 中校验非正容量错误路径。 +- [x] 在 C ABI 中校验小容量错误路径。 +- [x] 在 C ABI 中锁定 stress 展开顺序。 +- [x] 在 C ABI 中锁定 strain 展开顺序。 +- [x] 在 C ABI 中锁定 strain-rate 展开顺序。 +- [x] 在 C API 测试中覆盖 Solid 粒子级状态查询。 +- [x] 在 C API 测试中覆盖 Solid 0.5.1 错误路径。 +- [x] 在 C++ wrapper 中新增 Solid particle state 薄包装。 +- [x] 在 C++ API 测试中覆盖 Solid particle state 薄包装。 +- [x] 在 Python ctypes 中新增 Solid particle state 薄包装。 +- [x] 在 Python inspect 中追加 Solid 0.5.1 诊断字段。 +- [x] 在 Python run/checker 中覆盖 Solid 0.5.1 小模型。 +- [x] 在 Python checker 中覆盖 `STATE_0_5_1` restart 读回。 +- [x] 在 Python checker 中覆盖 `STATE_0_5` restart 兼容读入。 +- [x] 在 CLI inspect 中追加 `solid_max_strain_rate` 字段。 +- [x] 在 CLI inspect 中追加 `solid_max_acceleration` 字段。 +- [x] 在 CLI inspect 中追加 `solid_internal_force_residual` 字段。 +- [x] 在 CLI inspect 中追加 `solid_correction_status` 字段。 +- [x] 在 CLI inspect 中追加 `solid_reference_neighbor_min` 字段。 +- [x] 在 CLI run 中追加 Solid 0.5.1 诊断字段。 +- [x] 在 CLI checker 中覆盖 Solid 0.5.1 输入、run 和 restart。 +- [x] 确认新增 API 不改变 0.5.0 已有接口语义。 +- [x] 新增 `solid_state_api` 测试并接入 CTest。 +- [x] 新增 `solid_python_051` 测试并接入 CTest。 +- [x] 新增 `solid_cli_051` 测试并接入 CTest。 ## 阶段 I:源码尺寸、回归门禁、文档同步与发布准备 diff --git a/tools/testing/test_cli.py b/tools/testing/test_cli.py index eca2c73..1676105 100644 --- a/tools/testing/test_cli.py +++ b/tools/testing/test_cli.py @@ -114,6 +114,12 @@ def main() -> int: "solid_damage_max", "solid_softening_min", "solid_softening_max", + "solid_max_strain_rate", + "solid_max_acceleration", + "solid_internal_force_residual", + "solid_reference_neighbor_min", + "solid_correction_det_min", + "solid_correction_status", "solid_dt_cfl", "solid_dt_accel", "solid_dtcrit", diff --git a/tools/testing/test_python_debug.py b/tools/testing/test_python_debug.py index 943a111..56aa701 100644 --- a/tools/testing/test_python_debug.py +++ b/tools/testing/test_python_debug.py @@ -5,6 +5,34 @@ import sys from pathlib import Path +def write_state_050_compat(source: Path, target: Path, npart: int) -> None: + lines = source.read_text(encoding="utf-8").splitlines() + solid_material_count = 1 + solid_051_lines = 1 + 6 * solid_material_count + 8 + 9 * npart + solid_start = len(lines) - solid_051_lines + if solid_start <= 0: + raise AssertionError("could not locate Solid restart block") + lines[0] = "SPHLITE_RESTART 0 5 0 STATE_0_5" + + def skip_solid_line(relative_line: int) -> bool: + material_end = 1 + 6 * solid_material_count + if relative_line in (material_end + 6, material_end + 7): + return True + particle_start = material_end + 9 + if relative_line < particle_start: + return False + particle_line = (relative_line - particle_start) % 9 + return particle_line in (5, 6, 7) + + output: list[str] = [] + for index, line in enumerate(lines): + relative_line = index - solid_start + 1 + if relative_line > 0 and skip_solid_line(relative_line): + continue + output.append(line) + target.write_text("\n".join(output) + "\n", encoding="utf-8") + + def main() -> int: parser = argparse.ArgumentParser() parser.add_argument("--library", required=True) @@ -39,6 +67,10 @@ def main() -> int: 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 not hasattr(solver.lib, "sphlite_get_solid_particle_state"): + raise AssertionError("Python wrapper is missing Solid particle state C ABI") + if not hasattr(solver.lib, "sphlite_get_solid_diagnostics"): + raise AssertionError("Python wrapper is missing Solid 0.5.1 diagnostics C ABI") if solver.version() != (0, 5, 1): raise AssertionError("Python version mismatch") @@ -52,6 +84,11 @@ def main() -> int: state = solver.particle_state() if state["phase"][0] != PHASE_SOLID: raise AssertionError("unexpected particle phase") + solid_state = solver.solid_particle_state() + if len(solid_state["solid_values"]) != 22 * count: + raise AssertionError("solid particle state value layout mismatch") + if solid_state["solid_failure_status"][0] != STATUS_ACTIVE: + raise AssertionError("solid particle failure status mismatch") solid_summary = solver.inspect(args.input) if solid_summary["particles"] != 4: raise AssertionError("solid inspect summary mismatch") @@ -69,6 +106,10 @@ def main() -> int: 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") + if "solid_max_strain_rate" not in solid_summary: + raise AssertionError("inspect helper did not include Solid 0.5.1 diagnostics") + if "solid_reference_neighbor_min" not in solid_summary: + raise AssertionError("inspect helper did not include Solid reference quality") solver.set_output_directory(root / "build-codex-unix") solver.write_output(0, 0.0) restart = root / "build-codex-unix" / "python_restart.tmp" @@ -77,6 +118,15 @@ def main() -> int: restart_summary = solver.solid_summary() if restart_summary["solid_particles"] != 4: raise AssertionError("Solid restart summary mismatch") + restart_050 = root / "build-codex-unix" / "python_restart_050.tmp" + write_state_050_compat(restart, restart_050, count) + solver.read_restart(restart_050) + compat_summary = solver.solid_summary() + if compat_summary["solid_particles"] != 4: + raise AssertionError("Solid 0.5.0 restart summary mismatch") + compat_state = solver.solid_particle_state() + if len(compat_state["solid_values"]) != 22 * count: + raise AssertionError("Solid 0.5.0 restart particle state mismatch") solver.run_explicit() finally: solver.finalize() diff --git a/tools/testing/test_solid_cli.py b/tools/testing/test_solid_cli.py index 26c08c5..befa5ee 100644 --- a/tools/testing/test_solid_cli.py +++ b/tools/testing/test_solid_cli.py @@ -56,16 +56,30 @@ def main() -> int: raise AssertionError("Solid CLI inspect mass mismatch") if float(inspect["solid_dtcrit"]) <= 0.0: raise AssertionError("Solid CLI inspect dt mismatch") + for field in ( + "solid_max_strain_rate", + "solid_max_acceleration", + "solid_internal_force_residual", + "solid_reference_neighbor_min", + "solid_correction_det_min", + "solid_correction_status", + ): + if field not in inspect: + raise AssertionError(f"Solid CLI inspect missing {field}") 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") + if "solid_max_acceleration" not in run: + raise AssertionError("Solid CLI run missing 0.5.1 diagnostics") 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") + if "solid_max_strain_rate" not in summary: + raise AssertionError("Solid CLI output summary missing 0.5.1 diagnostics") solver = SPHLite(args.library) solver.initialize() @@ -78,6 +92,9 @@ def main() -> int: solid = solver.solid_summary() if solid["solid_particles"] != 4 or solid["solid_mass"] <= 0.0: raise AssertionError("Solid CLI restart checker mismatch") + state = solver.solid_particle_state() + if len(state["solid_values"]) != 22 * solid["solid_particles"]: + raise AssertionError("Solid CLI particle state checker mismatch") finally: solver.finalize() return 0