diff --git a/CMakeLists.txt b/CMakeLists.txt index e441546..932e5c0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.20) -project(SPHLite VERSION 0.8.2 LANGUAGES C CXX Fortran) +project(SPHLite VERSION 0.8.3 LANGUAGES C CXX Fortran) set(CMAKE_C_STANDARD 99) set(CMAKE_C_STANDARD_REQUIRED ON) @@ -10,7 +10,10 @@ set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) -set(CMAKE_Fortran_STANDARD 95) +# Algorithm-core Fortran targets are locked to Fortran 95 below. Peripheral +# integration layers, such as worker/CLI/IPC harnesses and their tests/tools, +# may use Fortran 2018. +set(CMAKE_Fortran_STANDARD 2018) set(CMAKE_Fortran_STANDARD_REQUIRED ON) set(CMAKE_Fortran_EXTENSIONS OFF) @@ -124,6 +127,9 @@ add_library(sphlite_core STATIC ${SPHLITE_CORE_SOURCES}) target_include_directories(sphlite_core PUBLIC "${SPHLITE_GENERATED_DIR}") set_target_properties(sphlite_core PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}" + Fortran_STANDARD 95 + Fortran_STANDARD_REQUIRED ON + Fortran_EXTENSIONS OFF POSITION_INDEPENDENT_CODE ON ) @@ -146,6 +152,7 @@ set_target_properties(sphlite_c_shared PROPERTIES OUTPUT_NAME sphlite_c) add_executable(sphlite src/app/sph_main.c src/app/sph_program.f90 + src/app/sph_worker_blocks.c src/app/sph_worker_cli.c src/app/sph_worker_contract.c src/app/sph_worker_dispatch.c @@ -153,6 +160,9 @@ add_executable(sphlite src/app/sph_worker_mock.c src/app/sph_worker_protocol.c src/app/sph_worker_reports.c + src/app/sph_worker_runtime.c + src/app/sph_worker_runtime_exchange.c + src/app/sph_worker_runtime_reports.c ) target_include_directories(sphlite PRIVATE include src/app) target_link_libraries(sphlite PRIVATE sphlite_c) @@ -202,8 +212,19 @@ target_include_directories(test_worker_contract PRIVATE src/app) add_test(NAME worker_contract COMMAND test_worker_contract) set_tests_properties(worker_contract PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_executable(test_worker_blocks + tests/app/test_worker_blocks.c + src/app/sph_worker_blocks.c + src/app/sph_worker_contract.c +) +target_include_directories(test_worker_blocks PRIVATE src/app) +add_test(NAME worker_blocks COMMAND test_worker_blocks) +set_tests_properties(worker_blocks PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_executable(test_worker_reports tests/app/test_worker_reports.c + src/app/sph_worker_blocks.c + src/app/sph_worker_contract.c src/app/sph_worker_reports.c src/app/sph_worker_protocol.c ) @@ -211,6 +232,38 @@ target_include_directories(test_worker_reports PRIVATE src/app) add_test(NAME worker_reports COMMAND test_worker_reports) set_tests_properties(worker_reports PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_executable(test_worker_runtime_reports + tests/app/test_worker_runtime_reports.c + src/app/sph_worker_blocks.c + src/app/sph_worker_cli.c + src/app/sph_worker_contract.c + src/app/sph_worker_ipc.c + src/app/sph_worker_protocol.c + src/app/sph_worker_reports.c + src/app/sph_worker_runtime_reports.c +) +target_include_directories(test_worker_runtime_reports PRIVATE src/app) +add_test(NAME worker_runtime_reports COMMAND test_worker_runtime_reports) +set_tests_properties(worker_runtime_reports PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + +add_executable(test_worker_ipc_selftest + tests/app/test_worker_ipc_selftest.c + src/app/sph_worker_blocks.c + src/app/sph_worker_cli.c + src/app/sph_worker_contract.c + src/app/sph_worker_dispatch.c + src/app/sph_worker_ipc.c + src/app/sph_worker_protocol.c + src/app/sph_worker_reports.c + src/app/sph_worker_runtime.c + src/app/sph_worker_runtime_exchange.c + src/app/sph_worker_runtime_reports.c +) +target_include_directories(test_worker_ipc_selftest PRIVATE include src/app) +target_link_libraries(test_worker_ipc_selftest PRIVATE sphlite_c) +add_test(NAME worker_ipc_selftest COMMAND test_worker_ipc_selftest) +set_tests_properties(worker_ipc_selftest PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_executable(test_worker_mock tests/app/test_worker_mock.c src/app/sph_worker_mock.c @@ -263,6 +316,12 @@ set_target_properties(test_input_coupling_load_errors_081 PROPERTIES Fortran_MOD add_test(NAME input_coupling_load_errors_081 COMMAND test_input_coupling_load_errors_081) set_tests_properties(input_coupling_load_errors_081 PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") +add_executable(test_input_cclite_082 tests/module/test_input_cclite_082.f90) +target_link_libraries(test_input_cclite_082 PRIVATE sphlite_core) +set_target_properties(test_input_cclite_082 PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") +add_test(NAME input_cclite_082 COMMAND test_input_cclite_082) +set_tests_properties(input_cclite_082 PROPERTIES WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}") + add_executable(test_coupling_contact_state_081 tests/module/test_coupling_contact_state_081.f90) target_link_libraries(test_coupling_contact_state_081 PRIVATE sphlite_core) set_target_properties(test_coupling_contact_state_081 PROPERTIES Fortran_MODULE_DIRECTORY "${SPHLITE_MODULE_DIR}") diff --git a/README.md b/README.md index cb0ab25..51be33a 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ SPHLite 是一个面向船舶水下接触爆炸的轻量级 SPH 多物理仿真软件。项目目标是支持水、爆炸产物气体、实体结构粒子、板壳结构粒子、破裂损伤,以及通过外部耦合模块与 FEMLite 进行接触和连续体耦合。 -当前发布版本:0.8.2。该版本定位为 CCLite worker 集成预研版,在 0.8.1 中立接触耦合接口稳定化基线之上新增 worker CLI 骨架、IPC adapter mock、命令映射、v2 数据契约、worker 诊断格式和 CCLite mock 命令闭环 gate。本地发布 gate 已通过;不交付真实 Windows shared memory/named event IPC、真实 CCLite 进程联调、真实 FEM-SPH 接触搜索、生产级 FSI 或工程级水下接触爆炸破坏 benchmark。 +当前发布版本:0.8.3。该版本定位为 CCLite worker 集成加固版,在 0.8.2 worker mock 契约基础上新增能力查询、Windows shared memory/named event IPC 适配器自测、AOR v1 粒子/力数据块、contact state 导入、`*SPHLITE CCLITE` 输入开关和 worker 诊断文件 gate。本地发布 gate 已通过;仍不交付真实外部 CCLite 进程联调、真实 FEM-SPH 接触搜索、生产级 FSI 或工程级水下接触爆炸破坏 benchmark。 代码仓库地址: @@ -40,7 +40,7 @@ SPHLite 的编译和测试要求应与 FEMLite 保持一致风格: - CMake 作为主构建系统。 - CTest 作为测试入口。 -- Fortran 95 用于核心求解器实现。 +- 算法核心 `sphlite_core` 维持 Fortran 95,包括求解器、粒子/单元语义、材料和物理模块;worker、CLI、IPC 等外围集成层及其测试/工具性 Fortran 代码可放宽到 Fortran 2018。 - C ABI 作为长期稳定的跨语言边界。 - C++ 作为 C ABI 之上的薄包装接口。 - Python 用于调试脚本、轻量后处理和验收检查。 @@ -63,9 +63,9 @@ SPHLite 的编译和测试要求应与 FEMLite 保持一致风格: ## 当前状态 -0.8.2 当前以 0.8.1 中立接触耦合接口稳定化版本为起点,完成 CCLite worker 集成预研和 mock 通信闭环。0.5.0 以来已完成内容主要包括: +0.8.3 当前以 0.8.2 CCLite worker mock 契约版本为起点,完成 SPHLite 侧 Windows IPC self-test、worker 数据块和诊断链路加固。0.5.0 以来已完成内容主要包括: -- CMake/CTest 工程骨架和 Fortran 95 核心库。 +- CMake/CTest 工程骨架、Fortran 95 算法核心库,以及可使用 Fortran 2018 的 worker/CLI/IPC 外围集成目标。 - C ABI、C++ 头文件薄包装和 Python `ctypes` 调试入口。 - Abaqus `.inp` 明确子集解析,以及 `*SPHLITE EOS`、`*SPHLITE VISCOSITY`、`*SPHLITE PARTICLE CONTROL`、`*SPHLITE BODY FORCE`。 - 3D Water 粒子的 Wendland/Cubic 核函数、uniform cell 邻域搜索、Tait EOS、Monaghan 人工黏性、连续性方程和 Velocity-Verlet 显式推进。 @@ -109,5 +109,6 @@ SPHLite 的编译和测试要求应与 FEMLite 保持一致风格: - 0.8.1 检查确认代码、构建脚本、测试和工具目录未新增 FEMLite 直接依赖,输出目录、CSV、VTK、restart 和临时结果未进入待提交清单。 - 0.8.1 仍不直接依赖 FEMLite,不实现外部 CouplingModule,不交付连续体耦合,不宣称工程级船舶水下接触爆炸破坏 benchmark。 - 0.8.2 新增 CCLite worker 入口骨架、IPC adapter mock、命令映射表、v2 数据契约草案、worker 诊断格式和 CCLite mock 命令闭环测试。 -- 0.8.2 本地发布 gate 已通过:完整 CTest 196/196,worker/coupling 专项 gate 56/56,source size 相关 gate 9/9,`git diff --check` 通过。 -- 0.8.2 仍不交付真实 Windows shared memory/named event IPC,不交付真实 CCLite 进程联调,不交付真实 SPH-FEM 接触/FSI。 +- 0.8.3 新增 `--cclite-capabilities`、Windows shared memory/named event IPC attach/loop 自测、AOR v1 粒子/力数据块、contact state 导入、`*SPHLITE CCLITE` 输入开关、worker log/particle report/force report 和 CCLite mock 命令闭环加固测试。 +- 0.8.3 本地发布 gate 已通过:完整 CTest 200/200,worker/coupling 专项 gate 55/55,source size 相关 gate 9/9,`git diff --check` 通过;无限水域爆炸示例脚本生成 VTU/PVD,`tools/publish_to_cclite.bat -TargetRoot ..\CCLite\SPHLite` 实际发布通过。 +- 0.8.3 仍不交付真实外部 CCLite 进程联调,不交付真实 SPH-FEM 接触/FSI,不交付生产级 CCLite 载荷求解。 diff --git a/docs/02_software_architecture_design.md b/docs/02_software_architecture_design.md index 16c2507..08e69ce 100644 --- a/docs/02_software_architecture_design.md +++ b/docs/02_software_architecture_design.md @@ -4,7 +4,7 @@ ## 1. 架构概览 -SPHLite 采用与 FEMLite 一致的 Fortran 95 风格过程式模块架构。核心求解器使用 Fortran 编写并遵守 Fortran 95 规范;C API/ABI、C++ 薄包装和 Python API 作为接口层提供,不作为核心求解实现语言。 +SPHLite 算法核心采用与 FEMLite 一致的 Fortran 95 风格过程式模块架构。`sphlite_core` 内的求解器、粒子/单元语义、材料、物理模块、数据库、输入解析、显式求解器和 Fortran API 继续遵守 Fortran 95 规范;worker、CLI、IPC 等外围集成层及其测试/工具性 Fortran 代码可放宽到 Fortran 2018。C API/ABI、C++ 薄包装和 Python API 作为接口层提供,不作为核心求解实现语言。 推荐的数据流: diff --git a/docs/03_detailed_design.md b/docs/03_detailed_design.md index c48fafa..991c1aa 100644 --- a/docs/03_detailed_design.md +++ b/docs/03_detailed_design.md @@ -4,7 +4,7 @@ ## 1. 设计原则 -SPHLite 核心使用 Fortran 95 实现,详细设计采用集中数组数据库和过程式模块协作方式。核心状态集中存放在 `sph_database` 一类模块中,物理模块围绕数据库读取通用状态、维护自身派生状态,并通过显式求解器推进。 +SPHLite 算法核心使用 Fortran 95 实现,详细设计采用集中数组数据库和过程式模块协作方式。核心状态集中存放在 `sph_database` 一类模块中,物理模块围绕数据库读取通用状态、维护自身派生状态,并通过显式求解器推进。求解器、粒子/单元语义、材料和物理模块不得引入 Fortran 2018 语法;worker、CLI、IPC 等外围集成层及其测试/工具性 Fortran 代码允许使用 Fortran 2018。 SPHLite 不采用面向对象的粒子类设计。输入文件中的 `*NODE` id 作为 external id 读取,数据库内部统一按 particle 管理。 diff --git a/docs/05_interface_control_document.md b/docs/05_interface_control_document.md index 9020fe8..73943ec 100644 --- a/docs/05_interface_control_document.md +++ b/docs/05_interface_control_document.md @@ -4,7 +4,7 @@ ## 1. 接口原则 -SPHLite 核心使用 Fortran 95 实现。公共接口分层如下: +SPHLite 算法核心使用 Fortran 95 实现,包括求解器、粒子/单元语义、材料和物理模块;worker、CLI、IPC 等外围集成层及其测试/工具性 Fortran 代码可放宽到 Fortran 2018。公共接口分层如下: - Fortran API:核心主接口,由 Fortran 模块提供。 - C ABI:长期稳定公共接口,统一使用 `sphlite_` 前缀。 @@ -165,7 +165,7 @@ SPHLite 不直接依赖 FEMLite,也不依赖外部 CouplingModule。C ABI 中 CouplingInterface 使用中立命名,必须支持每步交换。 -0.8.1/0.8.2 当前稳定 C ABI 清单: +0.8.1/0.8.2/0.8.3 当前稳定 C ABI 清单: ```c int sphlite_coupling_get_region_count(int *count); diff --git a/docs/06_test_and_verification_plan.md b/docs/06_test_and_verification_plan.md index 2fdc615..0c3ea95 100644 --- a/docs/06_test_and_verification_plan.md +++ b/docs/06_test_and_verification_plan.md @@ -4,7 +4,7 @@ ## 1. 测试原则 -SPHLite 测试体系仿照 FEMLite,采用 CMake + CTest + Python checker + release gate。核心求解器使用 Fortran 95,因此单元测试和模块测试以 Fortran 小程序为主。C ABI、C++ wrapper、Python API 和 CLI 作为接口层分别测试。 +SPHLite 测试体系仿照 FEMLite,采用 CMake + CTest + Python checker + release gate。求解器、粒子/单元语义、材料和物理模块等算法核心使用 Fortran 95;worker、CLI、IPC 等外围集成层及其测试/工具性 Fortran 代码可使用 Fortran 2018,但不得倒逼核心模块引入 Fortran 2018 语法。C ABI、C++ wrapper、Python API 和 CLI 作为接口层分别测试。 测试设计原则: @@ -489,30 +489,34 @@ git diff --check 0.8.1 不验收真实 FEMLite 联合运行,不验收外部 CouplingModule/CoupleLite/CoupledLite/CouplingLite,不验收连续体一部分 FEM 一部分 SPH 的生产级连续体耦合,不验收工程级船舶水下接触爆炸舱段破坏 benchmark,不验收生产级接触搜索、接触约束、摩擦、复杂撕裂/穿孔/碎片云、焊缝失效库、大规模并行或 GPU 后端。 -## 7.12 0.8.2 CCLite Worker Release Gate +## 7.12 0.8.3 CCLite Worker Release Gate -0.8.2 默认 gate 用于 CCLite 集成预研。验收对象是 worker CLI 参数、状态/命令枚举、IPC adapter mock、命令到 SPHLite API 的映射表、v2 数据契约草案、worker 诊断格式和 CCLite mock command/data block 闭环。 +0.8.3 worker gate 用于 CCLite 集成加固。验收对象是 worker CLI 参数、capabilities 查询、状态/命令枚举、IPC adapter mock、Windows shared memory/named event self-test、命令到 SPHLite API 的映射表、AOR v1 数据契约、worker 诊断文件和 CCLite mock command/data block 闭环。 专项测试: - `worker_protocol` - `worker_cli` - `worker_ipc` +- `worker_ipc_selftest` - `worker_dispatch` - `worker_contract` +- `worker_blocks` - `worker_reports` +- `worker_runtime_reports` - `worker_mock` +- `input_cclite_082` 建议命令: ```powershell -ctest --test-dir build-codex-unix -R "^(worker_protocol|worker_cli|worker_ipc|worker_dispatch|worker_contract|worker_reports|worker_mock)$" --output-on-failure +ctest --test-dir build-codex-unix -R "^(worker_protocol|worker_cli|worker_ipc|worker_ipc_selftest|worker_dispatch|worker_contract|worker_blocks|worker_reports|worker_runtime_reports|worker_mock|input_cclite_082)$" --output-on-failure ctest --test-dir build-codex-unix -R "^(worker|coupling_.*_08[01]|coupling_source_size_08[01])" --output-on-failure ``` -2026-07-05 本地结果:完整 CTest 196/196 通过,worker/coupling 专项 gate 56/56 通过,source size 相关 gate 9/9 通过,`git diff --check` 通过。无限水域爆炸示例脚本生成 VTU/PVD,`tools/publish_to_cclite.bat` dry run 通过。 +2026-07-05 本地结果:完整 CTest 200/200 通过,worker/coupling 专项 gate 55/55 通过,source size 相关 gate 9/9 通过,`git diff --check` 通过。无限水域爆炸示例脚本生成 VTU/PVD,`tools/publish_to_cclite.bat -TargetRoot ..\CCLite\SPHLite` 实际发布通过。 -该 gate 不验收真实 Windows shared memory/named event IPC,不验收真实 CCLite 进程联调,不验收 FEM-SPH 接触搜索、接触约束、摩擦、tied/release 物理作用或生产级 FSI。 +该 gate 已验收 SPHLite 侧 Windows shared memory/named event self-test,但不验收真实外部 CCLite 进程联调,不验收 FEM-SPH 接触搜索、接触约束、摩擦、tied/release 物理作用或生产级 FSI。 ## 8. Source Size 门禁 diff --git a/docs/09_release_history.md b/docs/09_release_history.md index 241f463..91c7cde 100644 --- a/docs/09_release_history.md +++ b/docs/09_release_history.md @@ -1,10 +1,10 @@ # 09 版本历史与验收记录 -文档状态:0.8.2 发布记录 +文档状态:0.8.3 发布记录 ## 1. 当前状态 -SPHLite 当前发布版本为 0.8.2 CCLite worker 集成预研版本。0.8.2 在 0.8.1 中立接触耦合接口稳定化版本基础上新增 worker CLI 骨架、IPC adapter mock、命令映射、v2 数据契约草案、worker 诊断格式和 CCLite mock 命令闭环 gate。0.8.2 不交付真实 Windows shared memory/named event IPC、真实 CCLite 进程联调、真实 FEM-SPH 接触搜索、生产级 FSI 或工程级水下接触爆炸舱段破坏 benchmark。 +SPHLite 当前发布版本为 0.8.3 CCLite worker 集成加固版本。0.8.3 在 0.8.2 worker mock 契约基础上新增能力查询、Windows shared memory/named event IPC 适配器自测、AOR v1 粒子/力数据块、contact state 导入、`*SPHLITE CCLITE` 输入开关、worker 诊断文件和 CCLite mock 命令闭环加固 gate。0.8.3 不交付真实外部 CCLite 进程联调、真实 FEM-SPH 接触搜索、生产级 FSI 或工程级水下接触爆炸舱段破坏 benchmark。 ## 2. 规划版本线 @@ -680,26 +680,25 @@ cmake --build build-codex-unix 版本定位: - 0.8.2 是 CCLite worker 集成预研版本。 -- 0.8.2 只稳定 worker 入口、mockable adapter、数据契约、诊断格式和 CCLite mock command/data block,不宣称真实 IPC 或真实 CCLite 联调完成。 +- 0.8.2 稳定 worker 入口、能力查询、mockable adapter、Windows shared memory/named event attach/loop 自测、数据契约、诊断格式和 CCLite mock command/data block;不宣称真实外部 CCLite 进程联调完成。 - 0.8.2 不改变 `STATE_0_8_1` restart schema;当前版本号更新为 0.8.2,restart 格式继续兼容 0.8.1 持久状态边界。 完成内容: - 新增 CCLite coupling manifest,记录 region、particle、facet、load、contact、motion、diagnostics 和 v2 预留字段。 -- 新增 `--cclite-worker` CLI 参数解析骨架,保留普通 CLI 行为不变;完整 worker 参数当前返回受控 `UNSUPPORTED`,不宣称真实 IPC。 -- 新增 worker 状态/命令/error code、ack 序号语义、IPC adapter mock、命令到现有 SPHLite API 的动作映射表。 -- 新增 v2 数据契约草案、valid flags、contact state 扩展、拒绝原因、per-region 诊断枚举和 boundary/ghost 预留缓存清零策略。 -- 新增 worker log、particle report、force report 格式工具,并确认 VTU/PVD 可继续用于 worker 结果复核。 +- 新增 `--cclite-worker` CLI 参数解析和 `--cclite-capabilities` 能力查询,保留普通 CLI 行为不变。 +- 新增 worker 状态/命令/error code、ack 序号语义、IPC adapter mock、Windows shared memory/named event attach/loop 自测和命令到现有 SPHLite API 的动作映射表。 +- 新增 AOR v1 粒子/力数据块、valid flags、contact state 扩展、拒绝原因、stale/repeated/nonfinite 计数、总力/总力矩统计和 boundary/ghost 预留缓存清零策略。 +- 新增 `*SPHLITE CCLITE` 输入开关、worker log、particle report、force report 输出工具,并确认 VTU/PVD 可继续用于 worker 结果复核。 - 新增 CCLite mock command/data block 闭环,覆盖 INIT、READ_INPUT、BUILD_MODEL、EXPORT_INTERFACE、IMPORT_LOADS、ADVANCE、WRITE_OUTPUT、STOP、100 step 空耦合和异常命令。 不交付范围: -- 不交付真实 Windows shared memory 或 named event IPC。 -- 不交付真实 CCLite 进程联调。 +- 不交付真实外部 CCLite 进程联调。 - 不交付真实 FEM-SPH 接触搜索、接触约束、摩擦、tied/release 物理作用或生产级 FSI。 验收结果: - `cmake --build build-codex-unix --parallel` 通过。 -- `ctest --test-dir build-codex-unix --output-on-failure` 通过:196/196。 -- worker/coupling 专项 gate 通过:56/56。 +- `ctest --test-dir build-codex-unix --output-on-failure` 通过:200/200。 +- worker/coupling 专项 gate 通过:55/55。 - source size 相关 gate 通过:9/9。 - `git diff --check` 通过。 - `examples/infinite_underwater_explosion` 双击脚本验证通过,并生成 VTU/PVD。 @@ -715,10 +714,47 @@ Pre-research CCLite worker integration contract - add CCLite coupling manifest, worker protocol, IPC adapter mock, API mapping, diagnostics format and mock command loop -- add worker CLI skeleton with controlled unsupported IPC path +- add worker CLI, capabilities and Windows IPC self-test path - add worker and coupling regression gates; keep ordinary CLI behavior intact ``` +### 0.8.3 发布记录 + +记录日期:2026-07-05 + +本地构建目录:`build-codex-unix` + +版本定位: +- 0.8.3 是 CCLite worker 集成加固版本。 +- 0.8.3 将算法核心继续约束为 Fortran 95,worker、CLI、IPC 等外围集成层可放宽到 Fortran 2018。 +- 0.8.3 在 0.8.2 worker mock 契约基础上,完成 SPHLite 侧 Windows shared memory/named event attach/loop self-test、AOR v1 粒子/力数据块、contact state 导入和 worker 诊断文件。 +- 0.8.3 不改变 `STATE_0_8_1` restart schema;当前版本号更新为 0.8.3,restart 格式继续兼容 0.8.1 持久状态边界。 + +完成内容: +- `--cclite-capabilities` 输出 solver、worker、IPC backend、command block version、data layout、平台相关 `supports_real_ipc` 和记录容量。 +- Windows 构建下新增 shared memory/named event attach、READY、命令 ack、DONE、STOP、timeout 和异常输入 self-test;非 Windows 平台仍返回受控 unsupported。 +- 新增 AOR v1 particle/force block 校验,覆盖 external id、export/internal index、valid flags、stale/repeated/nonfinite 拒绝、contact state 和总力/总力矩统计。 +- 新增 `*SPHLITE CCLITE` 输入关键词,提供 worker、region、export radius/sound speed、contact/boundary accept 开关。 +- 新增 worker runtime report 文件写入和路径管理,完善 worker log、particle report 和 force report。 +- 更新 README、06/09/11/12 号文档、worker protocol、IPC adapter、diagnostics、API mapping 和 coupling manifest。 + +不交付范围: +- 不交付真实外部 CCLite 进程联调。 +- 不交付真实 FEM-SPH 接触搜索、接触约束、摩擦、tied/release 物理作用或生产级 FSI。 +- 不交付生产级 CCLite 载荷求解或工程级船舶水下接触爆炸舱段破坏 benchmark。 + +验收结果: +- `cmake --build build-codex-unix --parallel` 通过。 +- `ctest --test-dir build-codex-unix --output-on-failure` 通过:200/200。 +- worker/coupling 专项 gate 通过:55/55。 +- source size 相关 gate 通过:9/9。 +- `git diff --check` 通过。 +- `examples/infinite_underwater_explosion` 双击脚本验证通过,并生成 VTU/PVD。 +- `tools/publish_to_cclite.bat -TargetRoot ..\CCLite\SPHLite` 实际发布通过,目标 manifest 版本为 0.8.3。 + +发布记录: +- 0.8.3 于 2026-07-05 完成本地发布 gate,并准备提交、标记 `v0.8.3` 和推送。 + 后续每个版本应记录: - 完成能力。 diff --git a/docs/11_benchmark_matrix.md b/docs/11_benchmark_matrix.md index 91de569..3e4f154 100644 --- a/docs/11_benchmark_matrix.md +++ b/docs/11_benchmark_matrix.md @@ -1,10 +1,10 @@ # 11 Benchmark 与验收矩阵 -文档状态:0.8.2 发布 gate 记录 +文档状态:0.8.3 发布 gate 记录 ## 1. 当前状态 -0.8.2 在 0.8.1 SPHLite 侧中立接触耦合接口稳定化 gate 基础上新增 CCLite worker 集成预研 gate。0.8.2 仍不作为真实 Windows shared memory/named event IPC、真实 CCLite 进程联调、真实 FEMLite 联合运行、连续体耦合或工程级水下接触爆炸 benchmark。 +0.8.3 在 0.8.2 CCLite worker mock 契约基础上新增 SPHLite 侧 Windows shared memory/named event self-test、AOR v1 粒子/力数据块、contact state 导入、`*SPHLITE CCLITE` 输入和 worker 诊断 gate。0.8.3 仍不作为真实外部 CCLite 进程联调、真实 FEMLite 联合运行、连续体耦合或工程级水下接触爆炸 benchmark。 ## 2. 0.1.0 Release Gate @@ -511,26 +511,30 @@ |---|---|---| | 2026-07-04 | `build-codex-unix` | 完整 CTest 189/189 通过,0.8.1 coupling 专项 gate 26/26 通过,0.8.0 coupling 回归 gate 24/24 通过,Water/Gas/Explosive/Solid/Shell 分类 gate 6/6、19/19、29/29、33/33、14/14 通过,0.7.0 blast 回归 gate 15/15 通过,0.7.1 blast 专项 gate 11/11 通过,source size 相关 gate 9/9 通过,`git diff --check` 通过 | -## 2.17 0.8.2 Release Gate +## 2.17 0.8.3 Release Gate -0.8.2 默认 gate 在 0.8.1 中立耦合接口稳定化版本之上验收 CCLite worker 集成预研能力。该 gate 只验收 worker 入口、mockable IPC adapter、命令映射、数据契约、诊断格式和 CCLite mock command/data block,不验收真实 IPC、真实 CCLite 进程联调或生产级 FSI。 +0.8.3 默认 gate 在 0.8.2 worker mock 契约版本之上验收 CCLite worker 集成加固能力。该 gate 验收 worker 入口、capabilities 查询、mockable IPC adapter、SPHLite 侧 Windows shared memory/named event 自测、命令映射、AOR v1 数据块、诊断文件和 CCLite mock command/data block,不验收真实外部 CCLite 进程联调或生产级 FSI。 | 测试名 | 类型 | 验收点 | |---|---|---| | `worker_protocol` | C worker | worker state、command、error code 和 ack 语义 | | `worker_cli` | C worker | `--cclite-worker` 参数解析、缺失/冲突错误和默认值 | | `worker_ipc` | C worker | IPC adapter mock、READY/DONE、wait/signal、timeout 和禁止 reset | +| `worker_ipc_selftest` | C worker | Windows shared memory/named event attach、READY、命令 ack、STOP、超时和异常输入 | | `worker_dispatch` | C worker | worker 命令到现有 SPHLite API 动作映射 | | `worker_contract` | C worker | v2 字段、valid flags、contact state、拒绝原因和 boundary/ghost 清零 | -| `worker_reports` | C worker | worker log、particle report、force report 和 VTU/PVD 复核边界 | +| `worker_blocks` | C worker | AOR v1 粒子/force 数据块、stale/repeated/nonfinite 拒绝和总力/总力矩统计 | +| `worker_reports` | C worker | worker log、particle report、force report 格式化与文件写入边界 | +| `worker_runtime_reports` | C worker | worker runtime 诊断文件 header、追加记录和路径管理 | | `worker_mock` | C worker | CCLite mock command/data block、100 step 空耦合和异常命令 | +| `input_cclite_082` | Fortran input | `*SPHLITE CCLITE` worker/region/export/accept 开关和错误路径 | -0.8.2 不改变 `STATE_0_8_1` restart schema,不验收真实 shared memory/named event IPC、真实 CCLite 进程联调、FEM-SPH 接触搜索、接触约束、摩擦、tied/release 物理作用或生产级 FSI。 +0.8.3 不改变 `STATE_0_8_1` restart schema,不验收真实外部 CCLite 进程联调、FEM-SPH 接触搜索、接触约束、摩擦、tied/release 物理作用或生产级 FSI。 本地验收记录: | 日期 | 构建目录 | 结果 | |---|---|---| -| 2026-07-05 | `build-codex-unix` | 完整 CTest 196/196 通过,worker/coupling 专项 gate 56/56 通过,source size 相关 gate 9/9 通过,`git diff --check` 通过;无限水域爆炸示例生成 VTU/PVD,发布脚本 dry run 通过 | +| 2026-07-05 | `build-codex-unix` | 完整 CTest 200/200 通过,worker/coupling 专项 gate 55/55 通过,source size 相关 gate 9/9 通过,`git diff --check` 通过;无限水域爆炸示例生成 VTU/PVD,发布脚本实际发布到 `..\CCLite\SPHLite` 通过 | ## 3. 基础数值矩阵 diff --git a/docs/12_cclite_integration_suggestions.md b/docs/12_cclite_integration_suggestions.md index ee4f0f6..4a1ac42 100644 --- a/docs/12_cclite_integration_suggestions.md +++ b/docs/12_cclite_integration_suggestions.md @@ -2,7 +2,7 @@ 文档状态:建议稿 -本文从 `..\CCLite\sphlite_suggests.md` 提取建议,并按 SPHLite 当前 0.8.2 能力进行修订。原文件中许多 0.1.x/0.2.x 的“起步改造”在 SPHLite 侧已经由 0.8.0/0.8.1 的 `CouplingInterface` 和 0.8.2 worker mock 契约覆盖,因此本文不再原样沿用版本号,而是按“现状、缺口、建议路线和验收”重新组织。 +本文从 `..\CCLite\sphlite_suggests.md` 提取建议,并按 SPHLite 当前 0.8.3 能力进行修订。原文件中许多 0.1.x/0.2.x 的“起步改造”在 SPHLite 侧已经由 0.8.0/0.8.1 的 `CouplingInterface`、0.8.2 worker mock 契约和 0.8.3 worker IPC self-test 覆盖,因此本文不再原样沿用版本号,而是按“现状、缺口、建议路线和验收”重新组织。CCLite 0.1.9 审计新增的“真实 worker 接入闭环”建议已在第 13 节逐条响应。 ## 1. 总体结论 @@ -23,9 +23,9 @@ SPHLite 独立求解器 ## 2. 当前 SPHLite 基线 -截至 0.8.2,SPHLite 已具备以下与 CCLite 集成相关的基础: +截至 0.8.3,SPHLite 已具备以下与 CCLite 集成相关的基础: -- Fortran 95 核心求解器,C ABI、C++ 薄包装、Python `ctypes` 和 CLI 均可用。 +- Fortran 95 算法核心求解器,C ABI、C++ 薄包装、Python `ctypes` 和 CLI 均可用;worker、CLI、IPC 等外围集成层及其测试/工具性 Fortran 代码可放宽到 Fortran 2018。 - `*SPHLITE COUPLING REGION` 输入已支持 `TYPE=CONTACT/CONTINUUM`。 - coupling region 已支持 `EXPORT=PARTICLE/FACET/BOTH`。 - 外部导入已支持 `IMPORT=FORCE/FACET_LOAD/MOTION`。 @@ -36,12 +36,12 @@ SPHLite 独立求解器 - C ABI 已提供 region info、region modes、粒子导出、facet proxy 导出、粒子力、facet load、facet pressure/traction/resultant、contact state、motion boundary、load balance 和 coupling diagnostics。 - 输出侧已具备 CSV、summary CSV、VTU、PVD 和 restart。 - 0.8.0/0.8.1 coupling release gate 已覆盖 mock coupling、输出、restart、Fortran/C/C++/Python/CLI 接口和 source size。 -- 0.8.2 worker release gate 已覆盖 worker CLI、协议、IPC mock、命令映射、v2 契约、诊断格式和 CCLite mock command/data block。 +- 0.8.3 worker release gate 已覆盖 worker CLI、能力查询、协议、IPC mock、Windows shared memory/named event self-test、命令映射、AOR v1 粒子/力数据块、诊断文件和 CCLite mock command/data block。 当前仍未交付的内容: -- CCLite worker/service IPC 模式。 -- Windows shared memory 与 named event 的打开、等待和响应。 +- 真实外部 CCLite worker/service 进程联调。 +- 由 CCLite 生产调度的 shared memory/named event 跨进程闭环。 - 与真实 CCLite 进程的联合运行。 - 真实 SPH-FEM 接触搜索、接触约束、摩擦、tied/release 和生产级 FSI。 - 连续体一部分 FEM、一部分 SPH 的生产级强耦合。 @@ -136,7 +136,7 @@ while true: worker 只 wait/signal,不 reset event。event 生命周期和 shared memory 生命周期由 CCLite 持有。 -当前 worker 入口参数、状态枚举、命令枚举、ack 序号和错误码记录在 [CCLite Worker Protocol](cclite_worker_protocol.md)。IPC 句柄、READY/DONE、wait/signal 和错误路径记录在 [CCLite Worker IPC Adapter](cclite_worker_ipc_adapter.md)。worker 命令到现有 API 的动作映射记录在 [CCLite Worker API Mapping](cclite_worker_api_mapping.md)。诊断输出记录在 [CCLite Worker Diagnostics](cclite_worker_diagnostics.md),mock 联调覆盖记录在 [CCLite Worker Mock Plan](cclite_worker_mock_plan.md)。0.8.x 阶段只把入口、mockable adapter 和纯逻辑协议骨架稳定下来,真实 IPC 在后续阶段实现。 +当前 worker 入口参数、状态枚举、命令枚举、ack 序号和错误码记录在 [CCLite Worker Protocol](cclite_worker_protocol.md)。IPC 句柄、READY/DONE、wait/signal 和错误路径记录在 [CCLite Worker IPC Adapter](cclite_worker_ipc_adapter.md)。worker 命令到现有 API 的动作映射记录在 [CCLite Worker API Mapping](cclite_worker_api_mapping.md)。诊断输出记录在 [CCLite Worker Diagnostics](cclite_worker_diagnostics.md),mock 联调覆盖记录在 [CCLite Worker Mock Plan](cclite_worker_mock_plan.md)。0.8.x 阶段已形成 CLI、能力查询、mock adapter、Windows shared memory/named event attach/loop self-test、worker 主循环骨架和数据块诊断输出;真实外部 CCLite 进程联调与生产级接触/FSI 仍在后续阶段验收。 ## 5. Coupling 数据契约建议 @@ -274,10 +274,10 @@ EXPORT_SOUND_SPEED=YES, ACCEPT_CONTACT_STATE=YES ### 9.2 下一阶段:CCLite worker 通信闭环 -- 已增加 `--cclite-worker` 参数解析骨架;真实 IPC 未实现时返回受控 `UNSUPPORTED`。 -- 已实现 command block/data block 名称抽象、READY/DONE、wait/signal 和 error code 的 mock adapter;真实 shared memory/named event 仍未实现。 -- 已支持 `INIT/READ_INPUT/BUILD_MODEL/EXPORT_INTERFACE/IMPORT_LOADS/ADVANCE/WRITE_OUTPUT/STOP` 的状态/动作映射。 -- 已完成 100 step 空耦合、空/固定粒子导出、空/粒子力/facet load 导入和异常命令的 CCLite mock 联调测试。 +- 已增加 `--cclite-worker` 参数解析骨架;非 Windows 或资源缺失时返回受控 `UNSUPPORTED`/`IPC`。 +- 已实现 command block/data block 名称抽象、READY/DONE、wait/signal、error code 的 mock adapter 和 Windows shared memory/named event attach 骨架。 +- 已支持 `INIT/READ_INPUT/BUILD_MODEL/EXPORT_INTERFACE/IMPORT_LOADS/ADVANCE/WRITE_OUTPUT/STOP` 的状态/动作映射,并接入粒子导出、粒子力导入、contact state 导入和 worker diagnostics 输出。 +- 已完成 100 step 空耦合、空/固定粒子导出、空/粒子力/contact state 导入和异常命令的 CCLite mock 联调测试,并完成 SPHLite 侧 Windows IPC self-test。 - 已通过普通 CLI 回归,C ABI、C++ wrapper 和 Python wrapper 仍保持原有路径。 ### 9.3 后续:数据契约 v2 @@ -361,3 +361,45 @@ EXPORT_SOUND_SPEED=YES, ACCEPT_CONTACT_STATE=YES - CCLite 接触算法核心。 - 生产级摩擦/绑定/释放约束。 - 外部耦合模块的调度器。 + +## 13. 新增建议逐条响应 + +`..\CCLite\sphlite_suggests.md` 第 15 节新增建议的核心判断是:SPHLite 0.8.2 已具备 worker 参数识别和 mock 契约,但真实 Windows shared memory/named event IPC worker 尚未闭合。0.8.3 已补齐 SPHLite 侧 Windows IPC self-test;真实外部 CCLite 进程联调仍需由 CCLite gate 验收。SPHLite 的修订响应如下。 + +| 新建议 | SPHLite 修订响应 | 状态与落点 | +| --- | --- | --- | +| 完整支持 CCLite 标准 worker 参数 | 保留 `--cclite-worker --solver-id SPH --case sphlite.inp --ipc-name ... --timeout-ms ...` 作为正式入口,普通 CLI 行为不得变化;参数缺失、冲突和未知参数应返回受控错误。 | 0.8.3 已完成参数骨架、mock 测试和 SPHLite 侧 Windows IPC self-test;真实外部 CCLite 进程联调继续加严校验。 | +| 实现真实 IPC worker 主循环 | 新增 Windows IPC adapter,打开 CCLite 创建的 command block、data block、command event 和 done event;非 Windows 平台返回明确 unsupported。 | 已完成 SPHLite 侧 attach/loop self-test;真实外部 CCLite 进程联调仍待验收。 | +| READY 与命令 ack 回写 | worker 启动后写入 `READY`;每条命令后回写 `ack_seq`、`worker_state`、`error_code` 和短消息。 | 已写入共享内存命令块,并由 Windows IPC self-test 覆盖。 | +| 只 wait/signal,不 reset event | SPHLite 只等待 command event、触发 done event;event reset、创建和销毁由 CCLite 持有。 | 作为不可破坏边界写入 worker gate。 | +| 优先闭合 `SPH_TO_CCL_PARTICLE` | 共享内存数据块先支持空粒子和固定粒子,再映射真实 coupling region 粒子导出;字段以 `cclite_coupling_manifest.md` 为准。 | 已实现 particle AOR v1 数据块导出、校验和 particle report;facet 数据块待补。 | +| 优先闭合 `CCL_TO_SPH_FORCE` | 共享内存导入先支持空 force block,再支持粒子力、接触状态和诊断字段;不得让 CCLite 直接写内部加速度/速度数组。 | 已实现 particle force/contact state ingest、stale/repeated/nonfinite 拒绝计数和 force report;facet load/motion 待补。 | +| 导出粒子严格检查 | 导出前检查有限值、有效半径、有效质量、有效状态、有效 external id 和有效 internal/export index;不合格粒子计数并跳过。 | 已进入 worker block 校验和 particle report。 | +| 导入 force record 严格检查 | 导入时检查 particle id、internal/export index、有限值、step_id、valid_flags 和重复/过期 epoch;无法匹配或非法记录拒绝并计数。 | 已进入 worker block 校验、force report 和 worker log total force/moment。 | +| 增加能力查询入口 | 新增 `sphlite.exe --cclite-capabilities`,输出 solver、worker 支持、IPC backend、command block version、data layout、real IPC 支持状态和记录容量。 | 已实现;Windows 构建报告 `supports_real_ipc=yes`,非 Windows 构建报告 `supports_real_ipc=no`。 | +| 增加 SPHLite 侧 self-test/smoke case | 在没有 FEMLite 的情况下验证 worker 启动、IPC attach、READY、空粒子导出、空 force 导入和 STOP 退出。 | 已增加 mock smoke 与 Windows IPC self-test。 | +| 与 CCLite 先验收三类联调路径 | 先验收真实 SPHLite + mock FEM 的 1 step 空耦合、100 step 空耦合、异常输入/超时可控退出。 | SPHLite 提供 worker、能力查询和诊断;跨进程调度由 CCLite gate 负责。 | +| mock 不等同真实耦合完成 | release note、测试名和能力查询必须区分 `mock worker`、`real IPC worker`、`real contact/FSI`。 | 0.8.2 可称为 SPHLite 侧 real IPC self-test 已覆盖,但不宣称真实外部 CCLite 联调或真实耦合完成。 | + +## 14. 原始建议覆盖清单 + +为避免遗漏,原始建议 1 到 16 章按以下口径完整响应: + +| 原始章节 | 响应 | +| --- | --- | +| 1 总体建议 | 采纳。SPHLite 保持独立求解器身份,只新增中立 CouplingInterface 和 worker/service adapter。 | +| 2 必须保持的边界 | 采纳。SPHLite、CCLite 和 FEMLite 的职责边界写入第 3 节,禁止 FEMLite 私有结构进入公开 ABI。 | +| 3 0.1.x 必要改造 | 已按 SPHLite 0.8.3 现状重映射。参数识别、mock 闭环和 SPHLite 侧 Windows IPC self-test 已完成,真实外部 CCLite 进程联调列为下一阶段最高优先级。 | +| 4 Worker/Service 模式 | 部分完成。0.8.3 已有 CLI、协议、mock adapter、Windows IPC adapter self-test 和命令映射;真实外部 CCLite 进程联调待实现。 | +| 5 Coupling Region 导出 | 大部分完成。当前 ABI 已支持 region 粒子和 facet proxy 导出;`body_id`、`contact_radius`、`sound_speed`、`valid_flags` 进入 v2 契约。 | +| 6 外部载荷导入 | 大部分完成。粒子力、facet load、pressure/traction/resultant 已支持;source id、pair id、moment、valid flags 和真实 IPC 拒绝计数待补强。 | +| 7 接触状态导入 | 部分完成。normal、gap、penetration、contact pressure 已有诊断;inactive/candidate/active/released/tied 枚举和 tied/release 映射作为后续增强。 | +| 8 Boundary/Ghost 与 FSI 预留 | 采纳为预留能力。先冻结数据契约和 smoke gate,不在真实 IPC 前宣称生产级 FSI。 | +| 9 输入文件建议 | 修订采纳。继续沿用现有 `*SPHLITE COUPLING REGION`,不新增重复 `SPH_REGION` 关键词;`*SPHLITE CCLITE` 仅作为未来辅助开关。 | +| 10 API/ABI 建议 | 修订采纳。保留现有 ABI,新增字段只进入 `_v2` 或 worker shared memory 契约,数组展开沿用 caller-allocated buffer 风格。 | +| 11 与 CCLite 版本路线配合 | 修订采纳。SPHLite 不照搬 CCLite 版本号,而按当前 0.8.x 基线、下一阶段真实 IPC 和长期 FSI 路线映射。 | +| 12 测试建议 | 采纳并扩展。worker、coupling 数据、FSI/工程预留 gate 已列入第 10 节,真实 IPC self-test 作为新增 gate。 | +| 13 诊断建议 | 采纳。worker log、particle report、force report、错误码、短消息、总力和总力矩已作为 worker diagnostics 输出。 | +| 14 优先级建议 | 采纳并重排。真实 IPC 闭环、能力查询、粒子/force 校验和 CCLite mock 联调列为最高优先级。 | +| 15 真实 worker 接入闭环 | 新增逐条响应见第 13 节。该建议是下一阶段 SPHLite 与 CCLite 集成的主线。 | +| 16 总结 | 采纳。SPHLite 提供稳定 region 数据、外部载荷通道、FSI 字段和诊断,不嵌入 FEMLite 或 CCLite 算法核心。 | diff --git a/docs/cclite_coupling_manifest.md b/docs/cclite_coupling_manifest.md index 2dca2cb..e1e5a8a 100644 --- a/docs/cclite_coupling_manifest.md +++ b/docs/cclite_coupling_manifest.md @@ -2,7 +2,7 @@ 文档状态:0.8.x 集成预研稿 -本文记录 SPHLite 与 CCLite worker/service adapter 之间的当前数据契约。它不替代 05 号接口控制文档,也不要求 SPHLite 直接依赖 CCLite 或 FEMLite;它只把当前 0.8.2 可用的 coupling ABI、CLI 诊断、worker mock 契约和后续 v2 预留字段整理成可检查清单。 +本文记录 SPHLite 与 CCLite worker/service adapter 之间的当前数据契约。它不替代 05 号接口控制文档,也不要求 SPHLite 直接依赖 CCLite 或 FEMLite;它只把当前 0.8.3 可用的 coupling ABI、CLI 诊断、worker IPC self-test 契约和后续 v2 预留字段整理成可检查清单。 ## 1. 范围复核 @@ -18,7 +18,7 @@ SPHLite 当前保持独立求解器定位。CCLite 负责 worker 启动、shared - contact state 支持法向、gap、penetration 和 contact pressure 导入诊断。 - motion boundary 支持 velocity/position target 的 direct 模式。 - 输出侧已具备 CSV、summary CSV、VTU、PVD 和 restart。 -- release gate 已覆盖 0.8.0/0.8.1 coupling 输入、导入、导出、restart、Fortran/C/C++/Python/CLI、0.8.2 worker mock 和 source size。 +- release gate 已覆盖 0.8.0/0.8.1 coupling 输入、导入、导出、restart、Fortran/C/C++/Python/CLI、0.8.2 worker mock、0.8.3 worker IPC self-test 和 source size。 当前仍不承诺的能力: @@ -284,21 +284,40 @@ v2 particle export 草案字段: |---|---| | `source_id` | 数据来源,CCLite 或其他外部模块负责分配 | | `pair_id` | SPH-FEM 或 SPH-boundary 配对 id | -| `body_id` | 船体部件、舱段或刚体分组 id | -| `contact_radius` | 由 `h`、section 或接触参数计算的等效接触半径 | -| `sound_speed` | phase/EOS 对应声速 | -| `valid_flags` | 逐字段有效性位 | +| `body_id` | 船体部件、舱段或刚体分组 id;当前默认 `-1` 表示未分配 | +| `contact_radius` | 由 `h`、section 或接触参数计算的等效接触半径;worker AOR v1 临时采用 `2h`,不改变内部核函数半径 | +| `sound_speed` | phase/EOS 对应声速;当前 worker AOR v1 没有稳定 EOS 查询时使用正占位值并通过 `valid_flags` 标识 | +| `valid_flags` | 逐字段有效性位;当前定义覆盖 position、velocity、normal、pressure、density、sound speed、moment、interface pressure 和 interface velocity | v2 force/contact/boundary 草案字段: | 接口 | 新增字段 | |---|---| -| particle force import v2 | `source_id`、`pair_id`、`moment[3]`、`valid_flags` | -| contact state import v2 | `source_id`、`pair_id`、`contact_state`、`valid_flags` | +| particle force import v2 | `source_id`、`pair_id`、`export_index`、`internal_index`、`moment[3]`、`valid_flags` | +| contact state import v2 | `source_id`、`pair_id`、`contact_state`、`contact_normal[3]`、`contact_gap`、`contact_penetration`、`contact_pressure`、`valid_flags` | | boundary state import v2 | `boundary_state_id`、`ghost_state_id`、`position[3]`、`velocity[3]`、`normal[3]`、`pressure`、`density`、`sound_speed`、`interface_pressure`、`interface_velocity[3]`、`state_mode`、`valid_flags` | C++ wrapper 应保留薄包装风格,把 v2 字段暴露为 POD/`std::vector` 容器;Python wrapper 应继续使用 `ctypes` caller-allocated buffer 风格,并提供 debug dict 视图。二者均不应引入 CCLite 私有类型。 +补充约定: + +- `source_id` 由 CCLite 或其他外部耦合模块分配,用于追踪 contact pair、facet 或边界来源;SPHLite 只保存和回显,不解释其内部结构。 +- `pair_id` 与 contact state 同步使用,用于标记同一接触对的 persistence;没有 contact state 时可为 0。 +- `moment[3]` 是 Solid/Shell 和后续壳粒子接触的预留字段;当前粒子力导入只使用 `force[3]`,但 force report 会保留 moment。 + +worker force block header 当前记录: + +| 字段 | 含义 | +|---|---| +| `stale_count` | 被拒绝的过期 step force record 数量 | +| `repeated_count` | 被拒绝的重复 force record 数量 | +| `contact_count` | 可映射到 contact state 导入的记录数量 | +| `total_force[3]` | 有效 force record 的导入总力 | +| `total_moment[3]` | 有效 force record 的导入总力矩 | +- `interface_pressure` 和 `interface_velocity[3]` 是 pressure projection/Riemann FSI 预留字段;当前不驱动生产级 FSI。 +- `sphlite_coupling_apply_boundary_states` 的草案接口只导入外部 boundary/ghost 状态,不规定 Water/Gas/Solid/Shell 如何参与邻域求和。 +- boundary/ghost 缓存容量应由后续 v2 ABI 或 worker data block 显式给出;每个 coupling step 开始前清零,避免 stale boundary state。 + ## 13. Diagnostics Draft 外部载荷和接触诊断扩展的目标是让每条导入记录“可追踪、可拒绝、可复现”。当前预留枚举见 `sph_worker_contract`,建议长期暴露以下类别: @@ -322,7 +341,7 @@ C++ wrapper 应保留薄包装风格,把 v2 字段暴露为 POD/`std::vector` ## 14. Boundary And Ghost Draft -boundary/ghost 当前是预留能力,而非生产级 FSI。`sphlite_worker_boundary_state_t` 只描述外部状态缓存和清零策略: +boundary/ghost 当前是预留能力,而非生产级 FSI。`sphlite_worker_boundary_state_t` 只描述外部状态缓存和清零策略;`sphlite_worker_boundary_state_clear` 是当前 smoke gate,用于保证状态可以完整清零。 | 字段 | 语义 | |---|---| diff --git a/docs/cclite_input_keyword.md b/docs/cclite_input_keyword.md new file mode 100644 index 0000000..dd46b00 --- /dev/null +++ b/docs/cclite_input_keyword.md @@ -0,0 +1,49 @@ +# SPHLite CCLite Input Keyword + +文档状态:0.8.x worker adapter 输入关键词草案 + +`*SPHLITE CCLITE` 是 SPHLite 侧 worker 集成提示关键词。它只保存 SPHLite 对 CCLite worker 数据交换的本地偏好,不生成几何、网格或粒子,不替代 CCLite 配置文件,也不负责匹配外部 FEM 区域。 + +## 1. 语法 + +```text +*SPHLITE CCLITE, WORKER=YES, REGION=ALL, + EXPORT_RADIUS=YES, EXPORT_SOUND_SPEED=YES, + ACCEPT_CONTACT_STATE=YES, ACCEPT_BOUNDARY_STATE=NO +``` + +所有选项均在关键词行内给出;当前不读取后续数据行。 + +## 2. 选项 + +| 选项 | 默认值 | 含义 | +|---|---|---| +| `WORKER` | `YES` | 当前输入文件声明可用于 SPHLite worker 模式;`NO` 表示不启用该提示 | +| `REGION` | `ALL` | SPHLite 侧 coupling region 名称;`ALL` 表示由 worker 导出全部启用 region | +| `EXPORT_RADIUS` | `YES` | worker 粒子数据块是否导出 `contact_radius` | +| `EXPORT_SOUND_SPEED` | `YES` | worker 粒子数据块是否导出 `sound_speed` | +| `ACCEPT_CONTACT_STATE` | `YES` | worker 是否接受 CCLite 写入的 contact state | +| `ACCEPT_BOUNDARY_STATE` | `NO` | boundary/ghost state 预留开关,当前只保存配置 | + +布尔选项接受 `YES/NO`、`ON/OFF`、`TRUE/FALSE`、`1/0`。 + +## 3. 与 Coupling Region 的关系 + +- `*SPHLITE COUPLING REGION` 仍定义 SPHLite 侧导出/导入 region、集合、phase/material/section 过滤、`EXPORT`、`IMPORT`、`LOAD_MODE`、`DISTRIBUTION` 和 `CONTACT_STATE`。 +- `*SPHLITE CCLITE, REGION=...` 只引用 region 名称,不创建 region。 +- `EXPORT_RADIUS` 和 `EXPORT_SOUND_SPEED` 对应 worker AOR 粒子数据块字段。 +- `ACCEPT_CONTACT_STATE=YES` 只有在 region 自身设置 `CONTACT_STATE=IMPORT` 时才会产生实际导入。 +- `ACCEPT_BOUNDARY_STATE` 为后续 boundary/ghost/FSI 数据块预留。 + +## 4. 当前实现边界 + +当前解析结果保存到 SPHLite database: + +- `cclite_worker_enabled` +- `cclite_region_name` +- `cclite_export_radius` +- `cclite_export_sound_speed` +- `cclite_accept_contact_state` +- `cclite_accept_boundary_state` + +当前 worker 数据块仍以 `cclite_coupling_manifest.md` 为准;本关键词不改变求解器时间推进、材料模型或 CouplingInterface 的数值算法。 diff --git a/docs/cclite_worker_api_mapping.md b/docs/cclite_worker_api_mapping.md index 9bfcff5..6e3f1f5 100644 --- a/docs/cclite_worker_api_mapping.md +++ b/docs/cclite_worker_api_mapping.md @@ -2,7 +2,7 @@ 文档状态:0.8.x mock 设计稿 -本文记录 worker 命令到 SPHLite 现有 API 的映射。当前实现为动作映射表,用于保证命令分发表不遗漏关键 ABI;真实执行将在 IPC 数据块和 worker 主循环稳定后接入。 +本文记录 worker 命令到 SPHLite 现有 API 的映射。当前实现包含动作映射表和真实 IPC 主循环骨架;主循环已接入 `INIT`、`READ_INPUT`、`BUILD_MODEL`、`EXPORT_INTERFACE` 粒子数据块、`IMPORT_LOADS` 粒子力与 contact state 数据块、`ADVANCE`、`WRITE_OUTPUT` 和 `STOP` 的基础路径。 ## 1. 命令映射 @@ -34,10 +34,10 @@ SPHLite API status 0 -> worker OK SPHLite API status 非 0 -> worker INTERNAL ``` -真实执行阶段应在返回 `INTERNAL` 前读取 `sphlite_get_last_error`,并把 last error 写入 worker log 和 command block error message。 +后续应在返回 `INTERNAL` 前读取 `sphlite_get_last_error`,并把 last error 写入 worker log 和 command block error message。 ## 3. 验收边界 -本阶段只保证命令到动作的映射完整,并提供 mock 测试。它不保证 shared memory 数据布局、真实载荷导入、真实推进或真实 CCLite 联调已经完成。 +本阶段保证命令到动作的映射完整,并提供 mock 测试和真实 IPC attach 骨架。它不保证真实 CCLite 跨进程联调、facet load/contact/motion 完整导入或生产级接触/FSI 已完成。 v2 预留字段、valid flags、contact state 扩展、拒绝原因和 boundary/ghost 缓存语义记录在 [CCLite Coupling Manifest](cclite_coupling_manifest.md),并由 `sph_worker_contract` 的 smoke 测试守住命名和清零策略。 diff --git a/docs/cclite_worker_diagnostics.md b/docs/cclite_worker_diagnostics.md index 13206f5..0cf61e7 100644 --- a/docs/cclite_worker_diagnostics.md +++ b/docs/cclite_worker_diagnostics.md @@ -1,43 +1,71 @@ # CCLite Worker Diagnostics -文档状态:0.8.x mock 设计稿 +文档状态:0.8.x worker adapter 当前实现说明 -本文记录 worker 诊断输出的文件名、字段和验收边界。当前实现提供格式工具和 smoke 测试,不在真实 worker 主循环中写文件。 +本文记录 worker 诊断输出的文件名、字段和验收边界。当前实现已经提供 log、particle report 和 force report 的路径解析、header 写入、记录追加和单元测试;真实跨进程 CCLite 联调仍需后续 self-test 验收。 ## 1. 输出文件 | 文件 | 内容 | |---|---| -| `sphlite_cclite_worker.log` | worker 启动参数、命令、ack、状态和错误 | -| `sphlite_cclite_particle_report.csv` | 每步导出的粒子摘要 | -| `sphlite_cclite_force_report.csv` | 每步接收的外部力/力矩和拒绝原因 | +| `sphlite_cclite_worker.log` | worker 启动参数、IPC 名称、命令、ack、状态、导出/导入计数、总力、总力矩和错误信息 | +| `sphlite_cclite_particle_report.csv` | 每次 `EXPORT_INTERFACE` 导出的粒子摘要和拒绝原因 | +| `sphlite_cclite_force_report.csv` | 每次 `IMPORT_LOADS` 接收的外部力、力矩、接触状态和拒绝原因 | + +路径规则: + +- `--log` 指向 worker log 文件。 +- particle report 和 force report 默认写入 `--log` 所在目录。 +- 未提供 `--log` 时使用当前工作目录下的默认文件名。 ## 2. Worker Log 字段 ```text -solver_id,command_block,data_prefix,command_id,step_id,ack_sequence, +solver_id,case_file,ipc_name,command_block,data_prefix,command_event, +done_event,timeout_ms,worker_id,command_id,step_id,ack_sequence, worker_state,exported_particles,exported_facets,received_forces, -error_code,error_message +total_fx,total_fy,total_fz,total_mx,total_my,total_mz, +nonfinite_particles,error_code,error_message ``` -这些字段覆盖启动参数日志、command/data block 名称、command id、step id、ack seq、worker state、导出数量、接收 force 数量以及错误码/错误消息。 +说明: + +- `command_block`、`data_prefix`、`command_event`、`done_event` 来自 worker IPC adapter。 +- `exported_particles` 来自粒子数据块 header。 +- `exported_facets` 当前保留为 0,等待 facet 数据块接入。 +- `received_forces`、`total_force` 和 `total_moment` 来自 force 数据块分析结果。 +- `nonfinite_particles` 记录导出粒子状态非有限拒绝计数。 +- `error_code` 和 `error_message` 记录启动、READY、命令执行和异常退出路径。 ## 3. CSV 字段 particle report: ```text -step_id,region_index,export_index,external_id,phase,status, -material,section,x,y,z,vx,vy,vz +step_id,region_index,export_index,internal_index,external_id, +phase,status,material,section,x,y,z,vx,vy,vz,reject_reason ``` force report: ```text -step_id,region_index,source_id,pair_id,target_id, -fx,fy,fz,mx,my,mz,reject_reason +step_id,region_index,source_id,pair_id,target_id,export_index, +internal_index,fx,fy,fz,mx,my,mz,contact_state,reject_reason ``` -## 4. VTK 复核 +拒绝原因使用 worker 契约中的枚举名称: -worker 结果复核可继续使用现有 VTU/PVD 输出。VTU/PVD 是 SPHLite 求解输出,不替代 worker log 和 CSV 诊断。 +- `unmatched_particle` +- `nonfinite_force` +- `nonfinite_contact` +- `invalid_weight` +- `stale_epoch` +- `repeated_import` + +## 4. 当前边界 + +- worker 已能把有效 particle force 映射到 `sphlite_coupling_apply_particle_forces`。 +- worker 已能把 active/candidate/tied contact state 映射到 `sphlite_coupling_apply_contact_state`。 +- stale step、重复 force record、非有限值和无效权重会在进入 CouplingInterface 前拒绝并计数。 +- facet export、facet load 和 motion boundary 的真实数据块仍是后续工作。 +- VTU/PVD 仍是 SPHLite 求解输出复核手段,不替代 worker log 和 CSV 诊断。 diff --git a/docs/cclite_worker_ipc_adapter.md b/docs/cclite_worker_ipc_adapter.md index 7295efc..a31833f 100644 --- a/docs/cclite_worker_ipc_adapter.md +++ b/docs/cclite_worker_ipc_adapter.md @@ -1,14 +1,15 @@ # CCLite Worker IPC Adapter -文档状态:0.8.x mock 设计稿 +文档状态:0.8.x IPC 骨架说明 -本文记录 SPHLite 侧 worker IPC adapter 的边界。当前实现是 mockable adapter,不打开真实 Windows shared memory 或 named event;真实 IPC 后续实现时应复用这里的句柄、状态和错误路径。 +本文记录 SPHLite 侧 worker IPC adapter 的边界。当前实现保留 mockable adapter,并新增 Windows shared memory/named event attach、wait、signal 和 close 路径;Windows 构建的能力查询报告 `supports_real_ipc=yes`,非 Windows 构建仍报告 `supports_real_ipc=no`。真实外部 CCLite 进程联调仍未验收。 ## 1. 模块边界 IPC adapter 只负责: - 保存 command block、data block、command event 和 done event 名称。 +- 打开 CCLite 预创建的 command/data shared memory 和 named event。 - 写入 `READY` 和 `DONE` 状态。 - 等待 command event。 - signal done event。 @@ -23,7 +24,7 @@ IPC adapter 不负责: ## 2. 句柄抽象 -当前 `sphlite_worker_ipc_t` 保存以下名称: +当前 `sphlite_worker_ipc_t` 保存以下名称和平台句柄: | 字段 | 默认命名 | |---|---| @@ -33,6 +34,8 @@ IPC adapter 不负责: | `command_event` | `.command_event` | | `done_event` | `.done_event` | +真实 Windows IPC 路径只打开 CCLite 持有的资源,不创建、不 reset、不销毁 CCLite 的资源。SPHLite 仅在自身退出时关闭本进程句柄和 view。 + 调用方也可以通过 CLI 的 `--command-block` 和 `--data-prefix` 覆盖默认名称。 ## 3. 状态流程 @@ -60,7 +63,7 @@ loop: | shared memory 或 event 尚未打开 | `IPC` | | wait 超时 | `TIMEOUT` | | event reset 尝试 | `CONFLICT` | -| Windows 真实 IPC 尚未实现 | `UNSUPPORTED` | -| 非 Windows 真实 IPC | `IPC` | +| Windows IPC 资源不存在或 attach 失败 | `IPC` | +| 非 Windows 真实 IPC | `UNSUPPORTED` | -mock 模式用于 CTest,不代表真实 IPC 能力完成。 +mock 模式用于 CTest,不代表真实 CCLite 进程联调完成;Windows IPC self-test 只证明 SPHLite 侧可打开、等待、响应和关闭标准 IPC 资源。 diff --git a/docs/cclite_worker_protocol.md b/docs/cclite_worker_protocol.md index e872d3b..ba1c0f6 100644 --- a/docs/cclite_worker_protocol.md +++ b/docs/cclite_worker_protocol.md @@ -2,7 +2,7 @@ 文档状态:0.8.x worker adapter 骨架说明 -本文记录 SPHLite 侧 CCLite worker 入口的参数、状态、命令和错误语义。当前实现只完成 CLI 解析、纯逻辑状态/命令枚举和测试;Windows shared memory、named event 和真实 CCLite 联调仍未实现。 +本文记录 SPHLite 侧 CCLite worker 入口的参数、状态、命令和错误语义。当前实现已完成 CLI 解析、能力查询、状态/命令枚举、mock 测试和 Windows shared memory/named event attach 骨架;真实 CCLite 跨进程联调、生产级接触/FSI 仍未完成。 ## 1. CLI 参数 @@ -34,7 +34,15 @@ sphlite.exe model.inp --check sphlite.exe model.inp --run --output result ``` -当前所有必填 worker 参数齐全时,程序会返回受控的 `UNSUPPORTED`,表示 IPC 阶段尚未实现。 +当前所有必填 worker 参数齐全时,程序会尝试打开 CCLite 创建的 IPC 资源。若资源不存在或平台不支持,会返回受控的 `IPC` 或 `UNSUPPORTED` 错误,不退回普通 CLI。 + +能力查询: + +```text +sphlite.exe --cclite-capabilities +``` + +`--cclite-capabilities` 必须单独使用,输出 key=value 能力清单。Windows 构建中 `supports_real_ipc=yes` 表示 SPHLite 侧 shared memory/named event attach、wait、signal 和 close 路径已进入 self-test;非 Windows 构建仍报告 `supports_real_ipc=no`。该标志不代表真实外部 CCLite 进程联调或生产级 FSI 已完成。 ## 2. 状态枚举 @@ -54,10 +62,10 @@ sphlite.exe model.inp --run --output result | `INIT` | 清理 worker 侧状态;允许从 `ERROR` 恢复到可继续状态 | | `READ_INPUT` | 后续映射到 `sphlite_read_inp` | | `BUILD_MODEL` | 后续映射到 `sphlite_build_model` | -| `EXPORT_INTERFACE` | 后续映射到 coupling region count/info、particle export 和 facet export | -| `IMPORT_LOADS` | 后续映射到 particle force、facet pressure/traction/resultant、contact state 和 motion boundary 导入 | -| `ADVANCE` | 后续映射到 `sphlite_advance_explicit` 或 worker 控制的子步循环 | -| `WRITE_OUTPUT` | 后续映射到 `sphlite_write_output` | +| `EXPORT_INTERFACE` | 映射到 coupling region count/info 和 particle export 数据块;facet export 后续补齐 | +| `IMPORT_LOADS` | 映射到空导入、particle force 数据块和 contact state 导入;facet load 和 motion boundary 后续补齐 | +| `ADVANCE` | 映射到 `sphlite_advance_explicit`,`dt<=0` 时使用稳定时间步估计 | +| `WRITE_OUTPUT` | 映射到 `sphlite_write_output` | | `STOP` | 写入完成状态后退出 worker | 未知命令进入 `ERROR`,错误码为 `UNKNOWN_COMMAND`。 diff --git a/src/app/sph_main.c b/src/app/sph_main.c index 66629f7..0648a2d 100644 --- a/src/app/sph_main.c +++ b/src/app/sph_main.c @@ -166,6 +166,10 @@ int main(int argc, char **argv) return 0; } + if (sphlite_worker_capabilities_requested(argc, argv)) { + return sphlite_worker_capabilities_main(argc, argv); + } + if (sphlite_worker_args_requested(argc, argv)) { return sphlite_worker_main(argc, argv); } diff --git a/src/app/sph_worker_blocks.c b/src/app/sph_worker_blocks.c new file mode 100644 index 0000000..c4f000b --- /dev/null +++ b/src/app/sph_worker_blocks.c @@ -0,0 +1,293 @@ +#include "sph_worker_blocks.h" + +#include +#include + +static int sphlite_worker_value_is_finite(double value) +{ + return value == value && value <= DBL_MAX && value >= -DBL_MAX; +} + +static int sphlite_worker_vector_is_finite(const double values[3]) +{ + return values != 0 && + sphlite_worker_value_is_finite(values[0]) && + sphlite_worker_value_is_finite(values[1]) && + sphlite_worker_value_is_finite(values[2]); +} + +static double sphlite_worker_vector_norm2(const double values[3]) +{ + return values[0] * values[0] + values[1] * values[1] + + values[2] * values[2]; +} + +static int sphlite_worker_contact_state_imported(int state) +{ + return state == SPHLITE_WORKER_CONTACT_CANDIDATE || + state == SPHLITE_WORKER_CONTACT_ACTIVE || + state == SPHLITE_WORKER_CONTACT_TIED; +} + +static void sphlite_worker_block_header_reset_diagnostics( + sphlite_worker_block_header_t *header) +{ + if (header != 0) { + header->rejected_count = 0; + header->nonfinite_count = 0; + header->stale_count = 0; + header->repeated_count = 0; + header->contact_count = 0; + header->total_force[0] = 0.0; + header->total_force[1] = 0.0; + header->total_force[2] = 0.0; + header->total_moment[0] = 0.0; + header->total_moment[1] = 0.0; + header->total_moment[2] = 0.0; + } +} + +void sphlite_worker_particle_record_clear(sphlite_worker_particle_record_t *record) +{ + if (record != 0) { + (void)memset(record, 0, sizeof(*record)); + record->body_id = -1; + record->reject_reason = SPHLITE_WORKER_REJECT_NONE; + } +} + +void sphlite_worker_force_record_clear(sphlite_worker_force_record_t *record) +{ + if (record != 0) { + (void)memset(record, 0, sizeof(*record)); + record->reject_reason = SPHLITE_WORKER_REJECT_NONE; + } +} + +void sphlite_worker_data_exchange_clear(sphlite_worker_data_exchange_t *data) +{ + if (data != 0) { + (void)memset(data, 0, sizeof(*data)); + data->particle_header.version = SPHLITE_WORKER_PARTICLE_BLOCK_VERSION; + data->particle_header.capacity = SPHLITE_WORKER_MAX_PARTICLE_RECORDS; + data->force_header.version = SPHLITE_WORKER_FORCE_BLOCK_VERSION; + data->force_header.capacity = SPHLITE_WORKER_MAX_FORCE_RECORDS; + } +} + +int sphlite_worker_particle_record_validate( + const sphlite_worker_particle_record_t *record, int *reject_reason) +{ + int reason = SPHLITE_WORKER_REJECT_NONE; + if (record == 0) { + reason = SPHLITE_WORKER_REJECT_UNMATCHED_PARTICLE; + } else if (record->particle_id_ext == 0 || record->internal_index <= 0) { + reason = SPHLITE_WORKER_REJECT_UNMATCHED_PARTICLE; + } else if (record->export_index <= 0) { + reason = SPHLITE_WORKER_REJECT_UNMATCHED_PARTICLE; + } else if (record->phase <= 0 || record->status < 0) { + reason = SPHLITE_WORKER_REJECT_UNMATCHED_PARTICLE; + } else if (!sphlite_worker_vector_is_finite(record->x) || + !sphlite_worker_vector_is_finite(record->v) || + !sphlite_worker_value_is_finite(record->pressure)) { + reason = SPHLITE_WORKER_REJECT_NONFINITE_CONTACT; + } else if (!sphlite_worker_value_is_finite(record->mass) || + !sphlite_worker_value_is_finite(record->density) || + !sphlite_worker_value_is_finite(record->volume) || + !sphlite_worker_value_is_finite(record->h) || + !sphlite_worker_value_is_finite(record->contact_radius) || + !sphlite_worker_value_is_finite(record->sound_speed) || + record->mass <= 0.0 || record->density <= 0.0 || + record->volume <= 0.0 || record->h <= 0.0 || + record->contact_radius <= 0.0 || record->sound_speed <= 0.0) { + reason = SPHLITE_WORKER_REJECT_INVALID_WEIGHT; + } else if (record->valid_flags == 0u) { + reason = SPHLITE_WORKER_REJECT_INVALID_WEIGHT; + } + if (reject_reason != 0) { + *reject_reason = reason; + } + return reason == SPHLITE_WORKER_REJECT_NONE ? 0 : -1; +} + +int sphlite_worker_force_record_validate( + const sphlite_worker_force_record_t *record, int *reject_reason) +{ + int reason = SPHLITE_WORKER_REJECT_NONE; + if (record == 0) { + reason = SPHLITE_WORKER_REJECT_UNMATCHED_PARTICLE; + } else if (record->particle_id_ext == 0 || record->internal_index <= 0 || + record->export_index <= 0) { + reason = SPHLITE_WORKER_REJECT_UNMATCHED_PARTICLE; + } else if (!sphlite_worker_vector_is_finite(record->force) || + !sphlite_worker_vector_is_finite(record->moment)) { + reason = SPHLITE_WORKER_REJECT_NONFINITE_FORCE; + } else if (record->load_mode < 0 || record->contact_state < 0 || + record->step_id < 0 || record->valid_flags == 0u) { + reason = SPHLITE_WORKER_REJECT_INVALID_WEIGHT; + } else if (sphlite_worker_contact_state_imported(record->contact_state) && + (!sphlite_worker_vector_is_finite(record->contact_normal) || + !sphlite_worker_value_is_finite(record->contact_gap) || + !sphlite_worker_value_is_finite(record->contact_penetration) || + !sphlite_worker_value_is_finite(record->contact_pressure))) { + reason = SPHLITE_WORKER_REJECT_NONFINITE_CONTACT; + } else if (sphlite_worker_contact_state_imported(record->contact_state) && + (!(record->valid_flags & SPHLITE_WORKER_VALID_NORMAL) || + sphlite_worker_vector_norm2(record->contact_normal) <= 1.0e-24)) { + reason = SPHLITE_WORKER_REJECT_INVALID_WEIGHT; + } + if (reject_reason != 0) { + *reject_reason = reason; + } + return reason == SPHLITE_WORKER_REJECT_NONE ? 0 : -1; +} + +int sphlite_worker_particle_block_add( + sphlite_worker_data_exchange_t *data, + const sphlite_worker_particle_record_t *record) +{ + int reason = SPHLITE_WORKER_REJECT_NONE; + if (data == 0 || record == 0 || + data->particle_header.version != SPHLITE_WORKER_PARTICLE_BLOCK_VERSION) { + return -1; + } + if (sphlite_worker_particle_record_validate(record, &reason) != 0) { + data->particle_header.rejected_count += 1; + if (reason == SPHLITE_WORKER_REJECT_NONFINITE_CONTACT) { + data->particle_header.nonfinite_count += 1; + } + return -1; + } + if (data->particle_header.count >= data->particle_header.capacity || + data->particle_header.count >= SPHLITE_WORKER_MAX_PARTICLE_RECORDS) { + data->particle_header.rejected_count += 1; + return -1; + } + data->particles[data->particle_header.count] = *record; + data->particle_header.count += 1; + return 0; +} + +int sphlite_worker_force_block_add( + sphlite_worker_data_exchange_t *data, + const sphlite_worker_force_record_t *record) +{ + int reason = SPHLITE_WORKER_REJECT_NONE; + if (data == 0 || record == 0 || + data->force_header.version != SPHLITE_WORKER_FORCE_BLOCK_VERSION) { + return -1; + } + if (sphlite_worker_force_record_validate(record, &reason) != 0) { + data->force_header.rejected_count += 1; + if (reason == SPHLITE_WORKER_REJECT_NONFINITE_FORCE) { + data->force_header.nonfinite_count += 1; + } else if (reason == SPHLITE_WORKER_REJECT_NONFINITE_CONTACT) { + data->force_header.nonfinite_count += 1; + } + return -1; + } + if (data->force_header.count >= data->force_header.capacity || + data->force_header.count >= SPHLITE_WORKER_MAX_FORCE_RECORDS) { + data->force_header.rejected_count += 1; + return -1; + } + data->forces[data->force_header.count] = *record; + data->force_header.count += 1; + return 0; +} + +static int sphlite_worker_force_record_is_duplicate( + const sphlite_worker_data_exchange_t *data, int position) +{ + int i; + const sphlite_worker_force_record_t *record; + + if (data == 0 || position <= 0 || + position >= data->force_header.count) { + return 0; + } + record = &data->forces[position]; + for (i = 0; i < position; ++i) { + const sphlite_worker_force_record_t *previous = &data->forces[i]; + if (previous->reject_reason != SPHLITE_WORKER_REJECT_NONE) { + continue; + } + if (previous->step_id == record->step_id && + previous->internal_index == record->internal_index && + previous->export_index == record->export_index && + previous->source_id == record->source_id && + previous->pair_id == record->pair_id) { + return 1; + } + } + return 0; +} + +int sphlite_worker_force_block_analyze( + sphlite_worker_data_exchange_t *data, int expected_step, + int *valid_count, int *contact_count) +{ + int valid = 0; + int contacts = 0; + int i; + + if (valid_count != 0) { + *valid_count = 0; + } + if (contact_count != 0) { + *contact_count = 0; + } + if (data == 0 || + data->force_header.version != SPHLITE_WORKER_FORCE_BLOCK_VERSION || + data->force_header.count < 0 || + data->force_header.count > data->force_header.capacity || + data->force_header.count > SPHLITE_WORKER_MAX_FORCE_RECORDS) { + return -1; + } + sphlite_worker_block_header_reset_diagnostics(&data->force_header); + for (i = 0; i < data->force_header.count; ++i) { + int reason = SPHLITE_WORKER_REJECT_NONE; + sphlite_worker_force_record_t *record = &data->forces[i]; + record->reject_reason = SPHLITE_WORKER_REJECT_NONE; + if (sphlite_worker_force_record_validate(record, &reason) != 0) { + record->reject_reason = reason; + data->force_header.rejected_count += 1; + if (reason == SPHLITE_WORKER_REJECT_NONFINITE_FORCE || + reason == SPHLITE_WORKER_REJECT_NONFINITE_CONTACT) { + data->force_header.nonfinite_count += 1; + } + continue; + } + if (expected_step > 0 && record->step_id > 0 && + record->step_id < expected_step) { + record->reject_reason = SPHLITE_WORKER_REJECT_STALE_EPOCH; + data->force_header.rejected_count += 1; + data->force_header.stale_count += 1; + continue; + } + if (sphlite_worker_force_record_is_duplicate(data, i)) { + record->reject_reason = SPHLITE_WORKER_REJECT_REPEATED_IMPORT; + data->force_header.rejected_count += 1; + data->force_header.repeated_count += 1; + continue; + } + data->force_header.total_force[0] += record->force[0]; + data->force_header.total_force[1] += record->force[1]; + data->force_header.total_force[2] += record->force[2]; + data->force_header.total_moment[0] += record->moment[0]; + data->force_header.total_moment[1] += record->moment[1]; + data->force_header.total_moment[2] += record->moment[2]; + valid += 1; + if (sphlite_worker_contact_state_imported(record->contact_state)) { + contacts += 1; + } + } + data->force_header.contact_count = contacts; + if (valid_count != 0) { + *valid_count = valid; + } + if (contact_count != 0) { + *contact_count = contacts; + } + return 0; +} diff --git a/src/app/sph_worker_blocks.h b/src/app/sph_worker_blocks.h new file mode 100644 index 0000000..f9212aa --- /dev/null +++ b/src/app/sph_worker_blocks.h @@ -0,0 +1,97 @@ +#ifndef SPHLITE_WORKER_BLOCKS_H +#define SPHLITE_WORKER_BLOCKS_H + +#include "sph_worker_contract.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define SPHLITE_WORKER_PARTICLE_BLOCK_VERSION 1 +#define SPHLITE_WORKER_FORCE_BLOCK_VERSION 1 +#define SPHLITE_WORKER_MAX_PARTICLE_RECORDS 4096 +#define SPHLITE_WORKER_MAX_FORCE_RECORDS 4096 + +typedef struct sphlite_worker_particle_record_t { + long long particle_id_ext; + int export_index; + int internal_index; + int phase; + int status; + int material_id; + int section_id; + int body_id; + double x[3]; + double v[3]; + double mass; + double density; + double volume; + double h; + double contact_radius; + double pressure; + double sound_speed; + unsigned int valid_flags; + int reject_reason; +} sphlite_worker_particle_record_t; + +typedef struct sphlite_worker_force_record_t { + long long particle_id_ext; + int export_index; + int internal_index; + double force[3]; + double moment[3]; + double contact_normal[3]; + double contact_gap; + double contact_penetration; + double contact_pressure; + long long source_id; + long long pair_id; + int load_mode; + int contact_state; + int step_id; + unsigned int valid_flags; + int reject_reason; +} sphlite_worker_force_record_t; + +typedef struct sphlite_worker_block_header_t { + int version; + int capacity; + int count; + int rejected_count; + int nonfinite_count; + int stale_count; + int repeated_count; + int contact_count; + double total_force[3]; + double total_moment[3]; +} sphlite_worker_block_header_t; + +typedef struct sphlite_worker_data_exchange_t { + sphlite_worker_block_header_t particle_header; + sphlite_worker_particle_record_t particles[SPHLITE_WORKER_MAX_PARTICLE_RECORDS]; + sphlite_worker_block_header_t force_header; + sphlite_worker_force_record_t forces[SPHLITE_WORKER_MAX_FORCE_RECORDS]; +} sphlite_worker_data_exchange_t; + +void sphlite_worker_data_exchange_clear(sphlite_worker_data_exchange_t *data); +void sphlite_worker_particle_record_clear(sphlite_worker_particle_record_t *record); +void sphlite_worker_force_record_clear(sphlite_worker_force_record_t *record); +int sphlite_worker_particle_record_validate( + const sphlite_worker_particle_record_t *record, int *reject_reason); +int sphlite_worker_force_record_validate( + const sphlite_worker_force_record_t *record, int *reject_reason); +int sphlite_worker_particle_block_add( + sphlite_worker_data_exchange_t *data, + const sphlite_worker_particle_record_t *record); +int sphlite_worker_force_block_add( + sphlite_worker_data_exchange_t *data, + const sphlite_worker_force_record_t *record); +int sphlite_worker_force_block_analyze( + sphlite_worker_data_exchange_t *data, int expected_step, + int *valid_count, int *contact_count); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/app/sph_worker_cli.c b/src/app/sph_worker_cli.c index 9be840f..bec3d30 100644 --- a/src/app/sph_worker_cli.c +++ b/src/app/sph_worker_cli.c @@ -53,6 +53,17 @@ int sphlite_worker_args_requested(int argc, char **argv) return 0; } +int sphlite_worker_capabilities_requested(int argc, char **argv) +{ + int i; + for (i = 1; i < argc; ++i) { + if (strcmp(argv[i], "--cclite-capabilities") == 0) { + return 1; + } + } + return 0; +} + void sphlite_worker_options_init(sphlite_worker_options_t *options) { if (options == 0) { @@ -158,36 +169,35 @@ int sphlite_worker_parse_args(int argc, char **argv, void sphlite_worker_print_usage(void) { printf("usage: sphlite --cclite-worker --solver-id SPH --case model.inp --ipc-name name [--command-block name] [--data-prefix prefix] [--log path] [--timeout-ms ms] [--worker-id id]\n"); + printf("usage: sphlite --cclite-capabilities\n"); } -int sphlite_worker_main(int argc, char **argv) +void sphlite_worker_print_capabilities(void) { - sphlite_worker_options_t options; - char message[256]; - int ierr; - message[0] = '\0'; - ierr = sphlite_worker_parse_args(argc, argv, &options, message, - (int)sizeof(message)); - if (ierr != 0) { - fprintf(stderr, "error_code: %d\n", - SPHLITE_WORKER_ERROR_ARGUMENT); - fprintf(stderr, "error_message: %s\n", message); + printf("solver=SPHLite\n"); + printf("cclite_worker=yes\n"); + printf("ipc_backend=windows_shmem_named_event\n"); + printf("command_block_version=1\n"); + printf("data_layout=AOR_V1\n"); +#ifdef _WIN32 + printf("supports_real_ipc=yes\n"); +#else + printf("supports_real_ipc=no\n"); +#endif + printf("supports_sph_to_ccl_particle=yes\n"); + printf("supports_ccl_to_sph_force=yes\n"); + printf("max_particle_records=4096\n"); +} + +int sphlite_worker_capabilities_main(int argc, char **argv) +{ + if (argc != 2 || argv == 0 || argv[1] == 0 || + strcmp(argv[1], "--cclite-capabilities") != 0) { + fprintf(stderr, "error_code: %d\n", SPHLITE_WORKER_ERROR_CONFLICT); + fprintf(stderr, "error_message: --cclite-capabilities must be used alone\n"); sphlite_worker_print_usage(); return 1; } - printf("worker_state: %s\n", - sphlite_worker_state_name(SPHLITE_WORKER_STATE_ERROR)); - printf("solver_id: %s\n", options.solver_id); - printf("case: %s\n", options.case_file); - printf("ipc_name: %s\n", options.ipc_name); - printf("command_block: %s\n", - options.command_block != 0 ? options.command_block : ""); - printf("data_prefix: %s\n", - options.data_prefix != 0 ? options.data_prefix : ""); - printf("log: %s\n", options.log_path); - printf("timeout_ms: %d\n", options.timeout_ms); - printf("worker_id: %s\n", options.worker_id); - printf("error_code: %d\n", SPHLITE_WORKER_ERROR_UNSUPPORTED); - printf("error_message: CCLite worker IPC is not implemented yet\n"); - return 2; + sphlite_worker_print_capabilities(); + return 0; } diff --git a/src/app/sph_worker_cli.h b/src/app/sph_worker_cli.h index 6ea1516..2f33c77 100644 --- a/src/app/sph_worker_cli.h +++ b/src/app/sph_worker_cli.h @@ -18,11 +18,14 @@ typedef struct sphlite_worker_options_t { } sphlite_worker_options_t; int sphlite_worker_args_requested(int argc, char **argv); +int sphlite_worker_capabilities_requested(int argc, char **argv); void sphlite_worker_options_init(sphlite_worker_options_t *options); int sphlite_worker_parse_args(int argc, char **argv, sphlite_worker_options_t *options, char *message, int message_capacity); void sphlite_worker_print_usage(void); +void sphlite_worker_print_capabilities(void); +int sphlite_worker_capabilities_main(int argc, char **argv); int sphlite_worker_main(int argc, char **argv); #ifdef __cplusplus diff --git a/src/app/sph_worker_ipc.c b/src/app/sph_worker_ipc.c index eae1165..9883ed0 100644 --- a/src/app/sph_worker_ipc.c +++ b/src/app/sph_worker_ipc.c @@ -3,6 +3,11 @@ #include #include +#ifdef _WIN32 +#define WIN32_LEAN_AND_MEAN +#include +#endif + static int sphlite_worker_copy_name(char *target, int capacity, const char *source) { @@ -29,6 +34,15 @@ static int sphlite_worker_derive_name(char *target, int capacity, return 0; } +static void sphlite_worker_ipc_copy_message(char *target, int capacity, + const char *message) +{ + if (target != 0 && capacity > 0) { + (void)snprintf(target, (size_t)capacity, "%s", + message != 0 ? message : ""); + } +} + const char *sphlite_worker_ipc_platform_name(int platform) { switch (platform) { @@ -91,27 +105,116 @@ int sphlite_worker_ipc_open(sphlite_worker_ipc_t *ipc, int use_mock, if (use_mock) { ipc->platform = SPHLITE_WORKER_IPC_PLATFORM_MOCK; ipc->opened = 1; + ipc->command_view = 0; + ipc->data_view = 0; *error_code = SPHLITE_WORKER_ERROR_OK; return 0; } #ifdef _WIN32 ipc->platform = SPHLITE_WORKER_IPC_PLATFORM_WINDOWS; - *error_code = SPHLITE_WORKER_ERROR_UNSUPPORTED; + ipc->command_mapping_handle = (void *)OpenFileMappingA( + FILE_MAP_ALL_ACCESS, FALSE, ipc->command_block); + if (ipc->command_mapping_handle == 0) { + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + ipc->command_view = MapViewOfFile((HANDLE)ipc->command_mapping_handle, + FILE_MAP_ALL_ACCESS, 0, 0, sizeof(sphlite_worker_command_block_t)); + if (ipc->command_view == 0) { + (void)sphlite_worker_ipc_close(ipc); + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + ipc->data_mapping_handle = (void *)OpenFileMappingA( + FILE_MAP_ALL_ACCESS, FALSE, ipc->data_prefix); + if (ipc->data_mapping_handle == 0) { + (void)sphlite_worker_ipc_close(ipc); + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + ipc->data_view = MapViewOfFile((HANDLE)ipc->data_mapping_handle, + FILE_MAP_ALL_ACCESS, 0, 0, 0); + if (ipc->data_view == 0) { + (void)sphlite_worker_ipc_close(ipc); + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + ipc->command_event_handle = (void *)OpenEventA( + SYNCHRONIZE, FALSE, ipc->command_event); + if (ipc->command_event_handle == 0) { + (void)sphlite_worker_ipc_close(ipc); + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + ipc->done_event_handle = (void *)OpenEventA( + EVENT_MODIFY_STATE, FALSE, ipc->done_event); + if (ipc->done_event_handle == 0) { + (void)sphlite_worker_ipc_close(ipc); + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + ipc->opened = 1; + *error_code = SPHLITE_WORKER_ERROR_OK; + return 0; #else ipc->platform = SPHLITE_WORKER_IPC_PLATFORM_UNSUPPORTED; - *error_code = SPHLITE_WORKER_ERROR_IPC; -#endif + *error_code = SPHLITE_WORKER_ERROR_UNSUPPORTED; return -1; +#endif +} + +int sphlite_worker_ipc_close(sphlite_worker_ipc_t *ipc) +{ + if (ipc == 0) { + return -1; + } +#ifdef _WIN32 + if (ipc->command_view != 0) { + (void)UnmapViewOfFile(ipc->command_view); + } + if (ipc->data_view != 0) { + (void)UnmapViewOfFile(ipc->data_view); + } + if (ipc->command_mapping_handle != 0) { + (void)CloseHandle((HANDLE)ipc->command_mapping_handle); + } + if (ipc->data_mapping_handle != 0) { + (void)CloseHandle((HANDLE)ipc->data_mapping_handle); + } + if (ipc->command_event_handle != 0) { + (void)CloseHandle((HANDLE)ipc->command_event_handle); + } + if (ipc->done_event_handle != 0) { + (void)CloseHandle((HANDLE)ipc->done_event_handle); + } +#endif + ipc->command_mapping_handle = 0; + ipc->data_mapping_handle = 0; + ipc->command_view = 0; + ipc->data_view = 0; + ipc->command_event_handle = 0; + ipc->done_event_handle = 0; + ipc->opened = 0; + return 0; } int sphlite_worker_ipc_write_ready(sphlite_worker_ipc_t *ipc, int *error_code) { + sphlite_worker_command_block_t *block; if (ipc == 0 || error_code == 0 || !ipc->opened) { if (error_code != 0) *error_code = SPHLITE_WORKER_ERROR_IPC; return -1; } ipc->ready_written += 1; + if (ipc->command_view != 0) { + block = (sphlite_worker_command_block_t *)ipc->command_view; + block->version = SPHLITE_WORKER_COMMAND_BLOCK_VERSION; + block->worker_state = SPHLITE_WORKER_STATE_READY; + block->error_code = SPHLITE_WORKER_ERROR_OK; + sphlite_worker_ipc_copy_message(block->message, + SPHLITE_WORKER_IPC_MESSAGE_CAPACITY, "READY"); + } *error_code = SPHLITE_WORKER_ERROR_OK; return 0; } @@ -119,6 +222,7 @@ int sphlite_worker_ipc_write_ready(sphlite_worker_ipc_t *ipc, int sphlite_worker_ipc_write_done(sphlite_worker_ipc_t *ipc, int ack_sequence, int state, int error_code) { + sphlite_worker_command_block_t *block; if (ipc == 0 || !ipc->opened) { return -1; } @@ -126,6 +230,43 @@ int sphlite_worker_ipc_write_done(sphlite_worker_ipc_t *ipc, int ack_sequence, ipc->command_sequence = ack_sequence; ipc->command_id = state; ipc->timed_out = error_code == SPHLITE_WORKER_ERROR_TIMEOUT ? 1 : 0; + if (ipc->command_view != 0) { + block = (sphlite_worker_command_block_t *)ipc->command_view; + block->ack_sequence = ack_sequence; + block->worker_state = state; + block->error_code = error_code; + sphlite_worker_ipc_copy_message(block->message, + SPHLITE_WORKER_IPC_MESSAGE_CAPACITY, + sphlite_worker_error_name(error_code)); + } + return 0; +} + +int sphlite_worker_ipc_read_command(sphlite_worker_ipc_t *ipc, + int *sequence, int *command, + double *dt, int *step_id, + int *error_code) +{ + sphlite_worker_command_block_t *block; + if (ipc == 0 || sequence == 0 || command == 0 || dt == 0 || + step_id == 0 || error_code == 0 || !ipc->opened) { + if (error_code != 0) *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + if (ipc->command_view == 0) { + *error_code = SPHLITE_WORKER_ERROR_UNSUPPORTED; + return -1; + } + block = (sphlite_worker_command_block_t *)ipc->command_view; + if (block->version != SPHLITE_WORKER_COMMAND_BLOCK_VERSION) { + *error_code = SPHLITE_WORKER_ERROR_CONFLICT; + return -1; + } + *sequence = block->sequence; + *command = block->command; + *dt = block->dt; + *step_id = block->step_id; + *error_code = SPHLITE_WORKER_ERROR_OK; return 0; } @@ -141,6 +282,26 @@ int sphlite_worker_ipc_wait_command(sphlite_worker_ipc_t *ipc, ipc->timed_out = 1; return -1; } +#ifdef _WIN32 + if (ipc->platform == SPHLITE_WORKER_IPC_PLATFORM_WINDOWS) { + DWORD wait_result; + if (ipc->command_event_handle == 0) { + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + wait_result = WaitForSingleObject((HANDLE)ipc->command_event_handle, + (DWORD)timeout_ms); + if (wait_result == WAIT_TIMEOUT) { + *error_code = SPHLITE_WORKER_ERROR_TIMEOUT; + ipc->timed_out = 1; + return -1; + } + if (wait_result != WAIT_OBJECT_0) { + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + } +#endif ipc->command_event_waits += 1; *error_code = SPHLITE_WORKER_ERROR_OK; return 0; @@ -153,6 +314,15 @@ int sphlite_worker_ipc_signal_done(sphlite_worker_ipc_t *ipc, if (error_code != 0) *error_code = SPHLITE_WORKER_ERROR_IPC; return -1; } +#ifdef _WIN32 + if (ipc->platform == SPHLITE_WORKER_IPC_PLATFORM_WINDOWS) { + if (ipc->done_event_handle == 0 || + !SetEvent((HANDLE)ipc->done_event_handle)) { + *error_code = SPHLITE_WORKER_ERROR_IPC; + return -1; + } + } +#endif ipc->done_event_signals += 1; *error_code = SPHLITE_WORKER_ERROR_OK; return 0; diff --git a/src/app/sph_worker_ipc.h b/src/app/sph_worker_ipc.h index 8ba93ef..4824ea7 100644 --- a/src/app/sph_worker_ipc.h +++ b/src/app/sph_worker_ipc.h @@ -8,6 +8,23 @@ extern "C" { #endif #define SPHLITE_WORKER_IPC_NAME_CAPACITY 128 +#define SPHLITE_WORKER_IPC_MESSAGE_CAPACITY 128 +#define SPHLITE_WORKER_COMMAND_BLOCK_VERSION 1 +#define SPHLITE_WORKER_DATA_LAYOUT_AOR_V1 1 + +typedef struct sphlite_worker_command_block_t { + int version; + int sequence; + int command; + int substep_id; + int iteration_id; + int step_id; + double dt; + int ack_sequence; + int worker_state; + int error_code; + char message[SPHLITE_WORKER_IPC_MESSAGE_CAPACITY]; +} sphlite_worker_command_block_t; typedef enum sphlite_worker_ipc_platform_t { SPHLITE_WORKER_IPC_PLATFORM_UNSUPPORTED = 0, @@ -31,6 +48,12 @@ typedef struct sphlite_worker_ipc_t { int command_sequence; int command_id; int timed_out; + void *command_mapping_handle; + void *data_mapping_handle; + void *command_view; + void *data_view; + void *command_event_handle; + void *done_event_handle; } sphlite_worker_ipc_t; const char *sphlite_worker_ipc_platform_name(int platform); @@ -40,10 +63,15 @@ int sphlite_worker_ipc_init(sphlite_worker_ipc_t *ipc, const char *data_prefix); int sphlite_worker_ipc_open(sphlite_worker_ipc_t *ipc, int use_mock, int *error_code); +int sphlite_worker_ipc_close(sphlite_worker_ipc_t *ipc); int sphlite_worker_ipc_write_ready(sphlite_worker_ipc_t *ipc, int *error_code); int sphlite_worker_ipc_write_done(sphlite_worker_ipc_t *ipc, int ack_sequence, int state, int error_code); +int sphlite_worker_ipc_read_command(sphlite_worker_ipc_t *ipc, + int *sequence, int *command, + double *dt, int *step_id, + int *error_code); int sphlite_worker_ipc_wait_command(sphlite_worker_ipc_t *ipc, int timeout_ms, int *error_code); int sphlite_worker_ipc_signal_done(sphlite_worker_ipc_t *ipc, diff --git a/src/app/sph_worker_reports.c b/src/app/sph_worker_reports.c index ed52722..c985826 100644 --- a/src/app/sph_worker_reports.c +++ b/src/app/sph_worker_reports.c @@ -1,7 +1,14 @@ #include "sph_worker_reports.h" +#include "sph_worker_contract.h" #include "sph_worker_protocol.h" #include +#include + +static const char *sphlite_worker_report_text(const char *text) +{ + return text == 0 ? "" : text; +} const char *sphlite_worker_report_filename(int report) { @@ -21,11 +28,11 @@ const char *sphlite_worker_report_header(int report) { switch (report) { case SPHLITE_WORKER_REPORT_LOG: - return "solver_id,command_block,data_prefix,command_id,step_id,ack_sequence,worker_state,exported_particles,exported_facets,received_forces,error_code,error_message"; + return "solver_id,case_file,ipc_name,command_block,data_prefix,command_event,done_event,timeout_ms,worker_id,command_id,step_id,ack_sequence,worker_state,exported_particles,exported_facets,received_forces,total_fx,total_fy,total_fz,total_mx,total_my,total_mz,nonfinite_particles,error_code,error_message"; case SPHLITE_WORKER_REPORT_PARTICLE: - return "step_id,region_index,export_index,external_id,phase,status,material,section,x,y,z,vx,vy,vz"; + return "step_id,region_index,export_index,internal_index,external_id,phase,status,material,section,x,y,z,vx,vy,vz,reject_reason"; case SPHLITE_WORKER_REPORT_FORCE: - return "step_id,region_index,source_id,pair_id,target_id,fx,fy,fz,mx,my,mz,reject_reason"; + return "step_id,region_index,source_id,pair_id,target_id,export_index,internal_index,fx,fy,fz,mx,my,mz,contact_state,reject_reason"; default: return ""; } @@ -36,31 +43,168 @@ int sphlite_worker_report_vtk_supported(void) return 1; } -int sphlite_worker_format_log_record(char *buffer, int capacity, - const char *solver_id, - const char *command_block, - const char *data_prefix, - int command_id, - int step_id, - int ack_sequence, - int worker_state, - int exported_particles, - int exported_facets, - int received_forces, - int error_code, - const char *error_message) +void sphlite_worker_log_record_clear(sphlite_worker_log_record_t *record) +{ + if (record != 0) { + (void)memset(record, 0, sizeof(*record)); + record->worker_state = SPHLITE_WORKER_STATE_CREATED; + } +} + +int sphlite_worker_format_log_record( + char *buffer, int capacity, const sphlite_worker_log_record_t *record) { int written; - if (buffer == 0 || capacity <= 0 || solver_id == 0 || - command_block == 0 || data_prefix == 0 || error_message == 0) { + if (buffer == 0 || capacity <= 0 || record == 0) { return -1; } written = snprintf(buffer, (size_t)capacity, - "%s,%s,%s,%d,%d,%d,%s,%d,%d,%d,%d,%s", - solver_id, command_block, data_prefix, command_id, step_id, - ack_sequence, sphlite_worker_state_name(worker_state), - exported_particles, exported_facets, received_forces, error_code, - error_message); + "%s,%s,%s,%s,%s,%s,%s,%d,%s,%d,%d,%d,%s,%d,%d,%d,%.16e,%.16e,%.16e,%.16e,%.16e,%.16e,%d,%d,%s", + sphlite_worker_report_text(record->solver_id), + sphlite_worker_report_text(record->case_file), + sphlite_worker_report_text(record->ipc_name), + sphlite_worker_report_text(record->command_block), + sphlite_worker_report_text(record->data_prefix), + sphlite_worker_report_text(record->command_event), + sphlite_worker_report_text(record->done_event), + record->timeout_ms, + sphlite_worker_report_text(record->worker_id), + record->command_id, record->step_id, record->ack_sequence, + sphlite_worker_state_name(record->worker_state), + record->exported_particles, record->exported_facets, + record->received_forces, + record->total_force[0], record->total_force[1], + record->total_force[2], record->total_moment[0], + record->total_moment[1], record->total_moment[2], + record->nonfinite_particles, record->error_code, + sphlite_worker_report_text(record->error_message)); + if (written < 0 || written >= capacity) { + return -1; + } + return 0; +} + +int sphlite_worker_format_particle_record( + char *buffer, int capacity, int step_id, int region_index, + const sphlite_worker_particle_record_t *record) +{ + int written; + if (buffer == 0 || capacity <= 0 || record == 0) { + return -1; + } + written = snprintf(buffer, (size_t)capacity, + "%d,%d,%d,%d,%lld,%d,%d,%d,%d,%.16e,%.16e,%.16e,%.16e,%.16e,%.16e,%s", + step_id, region_index, record->export_index, record->internal_index, + record->particle_id_ext, record->phase, record->status, + record->material_id, record->section_id, record->x[0], + record->x[1], record->x[2], record->v[0], record->v[1], + record->v[2], sphlite_worker_reject_reason_name( + record->reject_reason)); + if (written < 0 || written >= capacity) { + return -1; + } + return 0; +} + +int sphlite_worker_report_path( + char *buffer, int capacity, const char *log_path, int report) +{ + const char *base = log_path; + const char *filename = sphlite_worker_report_filename(report); + const char *slash; + const char *backslash; + const char *separator; + int written; + int prefix_len; + + if (buffer == 0 || capacity <= 0 || filename == 0 || filename[0] == '\0') { + return -1; + } + if (base == 0 || base[0] == '\0') { + base = sphlite_worker_report_filename(SPHLITE_WORKER_REPORT_LOG); + } + if (report == SPHLITE_WORKER_REPORT_LOG) { + written = snprintf(buffer, (size_t)capacity, "%s", base); + return written < 0 || written >= capacity ? -1 : 0; + } + slash = strrchr(base, '/'); + backslash = strrchr(base, '\\'); + if (slash == 0) { + separator = backslash; + } else if (backslash == 0) { + separator = slash; + } else { + separator = slash > backslash ? slash : backslash; + } + if (separator == 0) { + written = snprintf(buffer, (size_t)capacity, "%s", filename); + return written < 0 || written >= capacity ? -1 : 0; + } + prefix_len = (int)(separator - base) + 1; + if (prefix_len <= 0 || + prefix_len + (int)strlen(filename) >= capacity) { + return -1; + } + (void)memcpy(buffer, base, (size_t)prefix_len); + (void)snprintf(buffer + prefix_len, (size_t)(capacity - prefix_len), + "%s", filename); + return 0; +} + +int sphlite_worker_report_write_header(const char *path, int report) +{ + FILE *file; + const char *header = sphlite_worker_report_header(report); + + if (path == 0 || path[0] == '\0' || header == 0 || header[0] == '\0') { + return -1; + } + file = fopen(path, "w"); + if (file == 0) { + return -1; + } + if (fprintf(file, "%s\n", header) < 0) { + (void)fclose(file); + return -1; + } + return fclose(file) == 0 ? 0 : -1; +} + +int sphlite_worker_report_append_line(const char *path, const char *line) +{ + FILE *file; + + if (path == 0 || path[0] == '\0' || line == 0) { + return -1; + } + file = fopen(path, "a"); + if (file == 0) { + return -1; + } + if (fprintf(file, "%s\n", line) < 0) { + (void)fclose(file); + return -1; + } + return fclose(file) == 0 ? 0 : -1; +} + +int sphlite_worker_format_force_record( + char *buffer, int capacity, int step_id, int region_index, + const sphlite_worker_force_record_t *record) +{ + int written; + if (buffer == 0 || capacity <= 0 || record == 0) { + return -1; + } + written = snprintf(buffer, (size_t)capacity, + "%d,%d,%lld,%lld,%lld,%d,%d,%.16e,%.16e,%.16e,%.16e,%.16e,%.16e,%s,%s", + step_id, region_index, record->source_id, record->pair_id, + record->particle_id_ext, record->export_index, + record->internal_index, record->force[0], record->force[1], + record->force[2], record->moment[0], record->moment[1], + record->moment[2], sphlite_worker_contact_state_name( + record->contact_state), sphlite_worker_reject_reason_name( + record->reject_reason)); if (written < 0 || written >= capacity) { return -1; } diff --git a/src/app/sph_worker_reports.h b/src/app/sph_worker_reports.h index 9f993bc..5deb253 100644 --- a/src/app/sph_worker_reports.h +++ b/src/app/sph_worker_reports.h @@ -1,6 +1,8 @@ #ifndef SPHLITE_WORKER_REPORTS_H #define SPHLITE_WORKER_REPORTS_H +#include "sph_worker_blocks.h" + #ifdef __cplusplus extern "C" { #endif @@ -11,22 +13,48 @@ typedef enum sphlite_worker_report_t { SPHLITE_WORKER_REPORT_FORCE = 3 } sphlite_worker_report_t; +#define SPHLITE_WORKER_REPORT_PATH_CAPACITY 512 + +typedef struct sphlite_worker_log_record_t { + const char *solver_id; + const char *case_file; + const char *ipc_name; + const char *command_block; + const char *data_prefix; + const char *command_event; + const char *done_event; + const char *worker_id; + int timeout_ms; + int command_id; + int step_id; + int ack_sequence; + int worker_state; + int exported_particles; + int exported_facets; + int received_forces; + int nonfinite_particles; + double total_force[3]; + double total_moment[3]; + int error_code; + const char *error_message; +} sphlite_worker_log_record_t; + const char *sphlite_worker_report_filename(int report); const char *sphlite_worker_report_header(int report); int sphlite_worker_report_vtk_supported(void); -int sphlite_worker_format_log_record(char *buffer, int capacity, - const char *solver_id, - const char *command_block, - const char *data_prefix, - int command_id, - int step_id, - int ack_sequence, - int worker_state, - int exported_particles, - int exported_facets, - int received_forces, - int error_code, - const char *error_message); +void sphlite_worker_log_record_clear(sphlite_worker_log_record_t *record); +int sphlite_worker_format_log_record( + char *buffer, int capacity, const sphlite_worker_log_record_t *record); +int sphlite_worker_format_particle_record( + char *buffer, int capacity, int step_id, int region_index, + const sphlite_worker_particle_record_t *record); +int sphlite_worker_format_force_record( + char *buffer, int capacity, int step_id, int region_index, + const sphlite_worker_force_record_t *record); +int sphlite_worker_report_path( + char *buffer, int capacity, const char *log_path, int report); +int sphlite_worker_report_write_header(const char *path, int report); +int sphlite_worker_report_append_line(const char *path, const char *line); #ifdef __cplusplus } diff --git a/src/app/sph_worker_runtime.c b/src/app/sph_worker_runtime.c new file mode 100644 index 0000000..0e7c34c --- /dev/null +++ b/src/app/sph_worker_runtime.c @@ -0,0 +1,297 @@ +#include "sph_worker_runtime.h" + +#include "sph_worker_dispatch.h" +#include "sph_worker_ipc.h" +#include "sph_worker_runtime_exchange.h" +#include "sph_worker_runtime_reports.h" +#include "sphlite_c_api.h" + +#include + +typedef struct sphlite_worker_runtime_t { + int initialized; + int current_state; + int last_ack_sequence; +} sphlite_worker_runtime_t; + +static void sphlite_worker_runtime_init(sphlite_worker_runtime_t *runtime) +{ + runtime->initialized = 0; + runtime->current_state = SPHLITE_WORKER_STATE_READY; + runtime->last_ack_sequence = 0; +} + +static int sphlite_worker_runtime_ensure_initialized( + sphlite_worker_runtime_t *runtime) +{ + int ierr; + if (runtime->initialized) { + return 0; + } + ierr = sphlite_initialize(); + if (ierr == 0) { + runtime->initialized = 1; + } + return ierr; +} + +static int sphlite_worker_runtime_reset(sphlite_worker_runtime_t *runtime) +{ + int ierr = 0; + if (runtime->initialized) { + ierr = sphlite_finalize(); + runtime->initialized = 0; + if (ierr != 0) { + return ierr; + } + } + return sphlite_worker_runtime_ensure_initialized(runtime); +} + +static int sphlite_worker_runtime_execute( + sphlite_worker_runtime_t *runtime, + sphlite_worker_ipc_t *ipc, + const sphlite_worker_options_t *options, + const sphlite_worker_runtime_reports_t *reports, + int command, double dt, int step_id, int *stop_requested) +{ + double use_dt = dt; + double time = 0.0; + int current_step = 0; + int region_count = 0; + + *stop_requested = 0; + switch (command) { + case SPHLITE_WORKER_COMMAND_INIT: + return sphlite_worker_runtime_reset(runtime); + case SPHLITE_WORKER_COMMAND_READ_INPUT: + if (sphlite_worker_runtime_ensure_initialized(runtime) != 0) { + return -1; + } + return sphlite_read_inp(options->case_file); + case SPHLITE_WORKER_COMMAND_BUILD_MODEL: + return sphlite_build_model(); + case SPHLITE_WORKER_COMMAND_EXPORT_INTERFACE: + if (sphlite_worker_runtime_exchange_data(ipc) != 0) { + return sphlite_worker_runtime_export_particles(ipc, reports, + step_id); + } + return sphlite_coupling_get_region_count(®ion_count); + case SPHLITE_WORKER_COMMAND_IMPORT_LOADS: + return sphlite_worker_runtime_import_forces(ipc, reports, step_id); + case SPHLITE_WORKER_COMMAND_ADVANCE: + if (use_dt <= 0.0) { + if (sphlite_estimate_stable_dt(&use_dt) != 0) { + return -1; + } + } + return sphlite_advance_explicit(use_dt); + case SPHLITE_WORKER_COMMAND_WRITE_OUTPUT: + if (sphlite_get_current_time(&time, ¤t_step) != 0) { + return -1; + } + if (step_id > 0) { + current_step = step_id; + } + return sphlite_write_output(current_step, time); + case SPHLITE_WORKER_COMMAND_STOP: + if (runtime->initialized) { + (void)sphlite_finalize(); + runtime->initialized = 0; + } + *stop_requested = 1; + return 0; + default: + return -1; + } +} + +static int sphlite_worker_runtime_finish( + sphlite_worker_ipc_t *ipc, int sequence, int state, int error_code) +{ + int signal_error = SPHLITE_WORKER_ERROR_OK; + if (sphlite_worker_ipc_write_done(ipc, sequence, state, + error_code) != 0) { + return -1; + } + if (sphlite_worker_ipc_signal_done(ipc, &signal_error) != 0) { + return -1; + } + return 0; +} + +static int sphlite_worker_runtime_loop( + sphlite_worker_ipc_t *ipc, + const sphlite_worker_options_t *options, + sphlite_worker_runtime_t *runtime, + const sphlite_worker_runtime_reports_t *reports) +{ + int stop_requested = 0; + while (!stop_requested) { + int error_code = SPHLITE_WORKER_ERROR_OK; + int sequence = 0; + int command = SPHLITE_WORKER_COMMAND_UNKNOWN; + int step_id = 0; + int next_state = SPHLITE_WORKER_STATE_ERROR; + int action_error = SPHLITE_WORKER_ERROR_OK; + double dt = 0.0; + int api_status = 0; + + if (sphlite_worker_ipc_wait_command(ipc, options->timeout_ms, + &error_code) != 0) { + (void)sphlite_worker_runtime_finish(ipc, + runtime->last_ack_sequence, SPHLITE_WORKER_STATE_ERROR, + error_code); + sphlite_worker_runtime_reports_log(reports, options, ipc, + sphlite_worker_runtime_exchange_data(ipc), command, step_id, + runtime->last_ack_sequence, SPHLITE_WORKER_STATE_ERROR, 0, + error_code, "worker command wait failed"); + return 2; + } + if (sphlite_worker_ipc_read_command(ipc, &sequence, &command, &dt, + &step_id, &error_code) != 0) { + (void)sphlite_worker_runtime_finish(ipc, + runtime->last_ack_sequence, SPHLITE_WORKER_STATE_ERROR, + error_code); + sphlite_worker_runtime_reports_log(reports, options, ipc, + sphlite_worker_runtime_exchange_data(ipc), command, step_id, + runtime->last_ack_sequence, SPHLITE_WORKER_STATE_ERROR, 0, + error_code, "worker command read failed"); + return 2; + } + if (!sphlite_worker_ack_is_new(runtime->last_ack_sequence, + sequence)) { + (void)sphlite_worker_runtime_finish(ipc, sequence, + SPHLITE_WORKER_STATE_ERROR, SPHLITE_WORKER_ERROR_CONFLICT); + sphlite_worker_runtime_reports_log(reports, options, ipc, + sphlite_worker_runtime_exchange_data(ipc), command, step_id, + sequence, SPHLITE_WORKER_STATE_ERROR, 0, + SPHLITE_WORKER_ERROR_CONFLICT, + "worker command sequence conflict"); + return 2; + } + if (sphlite_worker_next_state(runtime->current_state, command, 0, + &next_state, &action_error) != 0) { + (void)sphlite_worker_runtime_finish(ipc, sequence, next_state, + action_error); + runtime->last_ack_sequence = sequence; + runtime->current_state = next_state; + sphlite_worker_runtime_reports_log(reports, options, ipc, + sphlite_worker_runtime_exchange_data(ipc), command, step_id, + sequence, next_state, 0, action_error, + "worker command rejected by state machine"); + return 2; + } + api_status = sphlite_worker_runtime_execute(runtime, ipc, options, + reports, command, dt, step_id, &stop_requested); + if (api_status != 0) { + next_state = SPHLITE_WORKER_STATE_ERROR; + action_error = sphlite_worker_error_from_api_status(api_status); + } + if (sphlite_worker_runtime_finish(ipc, sequence, next_state, + action_error) != 0) { + return 2; + } + sphlite_worker_runtime_reports_log(reports, options, ipc, + sphlite_worker_runtime_exchange_data(ipc), command, step_id, + sequence, next_state, 0, action_error, + action_error == SPHLITE_WORKER_ERROR_OK ? "ok" : + "worker command failed"); + runtime->last_ack_sequence = sequence; + runtime->current_state = next_state; + if (action_error != SPHLITE_WORKER_ERROR_OK) { + return 2; + } + } + return 0; +} + +int sphlite_worker_run_real_ipc(const sphlite_worker_options_t *options) +{ + sphlite_worker_ipc_t ipc; + sphlite_worker_runtime_t runtime; + sphlite_worker_runtime_reports_t reports; + int error_code = SPHLITE_WORKER_ERROR_OK; + int result; + + if (options == 0) { + return 1; + } + sphlite_worker_runtime_init(&runtime); + sphlite_worker_runtime_reports_init(&reports, options); + sphlite_worker_runtime_reports_prepare(&reports); + if (sphlite_worker_ipc_init(&ipc, options->ipc_name, + options->command_block, options->data_prefix) != 0) { + fprintf(stderr, "error_code: %d\n", SPHLITE_WORKER_ERROR_ARGUMENT); + fprintf(stderr, "error_message: invalid worker IPC names\n"); + sphlite_worker_runtime_reports_log(&reports, options, 0, 0, + SPHLITE_WORKER_COMMAND_UNKNOWN, 0, 0, + SPHLITE_WORKER_STATE_ERROR, 0, SPHLITE_WORKER_ERROR_ARGUMENT, + "invalid worker IPC names"); + return 1; + } + sphlite_worker_runtime_reports_log(&reports, options, &ipc, 0, + SPHLITE_WORKER_COMMAND_UNKNOWN, 0, 0, SPHLITE_WORKER_STATE_CREATED, + 0, SPHLITE_WORKER_ERROR_OK, "worker startup"); + if (sphlite_worker_ipc_open(&ipc, 0, &error_code) != 0) { + printf("worker_state: %s\n", + sphlite_worker_state_name(SPHLITE_WORKER_STATE_ERROR)); + printf("solver_id: %s\n", options->solver_id); + printf("case: %s\n", options->case_file); + printf("ipc_name: %s\n", options->ipc_name); + printf("command_block: %s\n", ipc.command_block); + printf("data_prefix: %s\n", ipc.data_prefix); + printf("command_event: %s\n", ipc.command_event); + printf("done_event: %s\n", ipc.done_event); + printf("log: %s\n", options->log_path); + printf("timeout_ms: %d\n", options->timeout_ms); + printf("worker_id: %s\n", options->worker_id); + printf("ipc_platform: %s\n", + sphlite_worker_ipc_platform_name(ipc.platform)); + printf("error_code: %d\n", error_code); + printf("error_message: worker IPC attach failed\n"); + sphlite_worker_runtime_reports_log(&reports, options, &ipc, 0, + SPHLITE_WORKER_COMMAND_UNKNOWN, 0, 0, + SPHLITE_WORKER_STATE_ERROR, 0, error_code, + "worker IPC attach failed"); + (void)sphlite_worker_ipc_close(&ipc); + return 2; + } + if (sphlite_worker_ipc_write_ready(&ipc, &error_code) != 0 || + sphlite_worker_ipc_signal_done(&ipc, &error_code) != 0) { + printf("worker_state: %s\n", + sphlite_worker_state_name(SPHLITE_WORKER_STATE_ERROR)); + printf("error_code: %d\n", error_code); + printf("error_message: worker READY signal failed\n"); + sphlite_worker_runtime_reports_log(&reports, options, &ipc, 0, + SPHLITE_WORKER_COMMAND_UNKNOWN, 0, 0, + SPHLITE_WORKER_STATE_ERROR, 0, error_code, + "worker READY signal failed"); + (void)sphlite_worker_ipc_close(&ipc); + return 2; + } + sphlite_worker_runtime_reports_log(&reports, options, &ipc, 0, + SPHLITE_WORKER_COMMAND_UNKNOWN, 0, 0, SPHLITE_WORKER_STATE_READY, + 0, SPHLITE_WORKER_ERROR_OK, "worker ready"); + result = sphlite_worker_runtime_loop(&ipc, options, &runtime, &reports); + (void)sphlite_worker_ipc_close(&ipc); + return result; +} + +int sphlite_worker_main(int argc, char **argv) +{ + sphlite_worker_options_t options; + char message[256]; + int ierr; + message[0] = '\0'; + ierr = sphlite_worker_parse_args(argc, argv, &options, message, + (int)sizeof(message)); + if (ierr != 0) { + fprintf(stderr, "error_code: %d\n", + SPHLITE_WORKER_ERROR_ARGUMENT); + fprintf(stderr, "error_message: %s\n", message); + sphlite_worker_print_usage(); + return 1; + } + return sphlite_worker_run_real_ipc(&options); +} diff --git a/src/app/sph_worker_runtime.h b/src/app/sph_worker_runtime.h new file mode 100644 index 0000000..356cb70 --- /dev/null +++ b/src/app/sph_worker_runtime.h @@ -0,0 +1,16 @@ +#ifndef SPHLITE_WORKER_RUNTIME_H +#define SPHLITE_WORKER_RUNTIME_H + +#include "sph_worker_cli.h" + +#ifdef __cplusplus +extern "C" { +#endif + +int sphlite_worker_run_real_ipc(const sphlite_worker_options_t *options); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/app/sph_worker_runtime_exchange.c b/src/app/sph_worker_runtime_exchange.c new file mode 100644 index 0000000..6b1a2f6 --- /dev/null +++ b/src/app/sph_worker_runtime_exchange.c @@ -0,0 +1,274 @@ +#include "sph_worker_runtime_exchange.h" + +#include "sphlite_c_api.h" + +#include + +static int sphlite_worker_runtime_contact_state_imported(int state) +{ + return state == SPHLITE_WORKER_CONTACT_CANDIDATE || + state == SPHLITE_WORKER_CONTACT_ACTIVE || + state == SPHLITE_WORKER_CONTACT_TIED; +} + +sphlite_worker_data_exchange_t *sphlite_worker_runtime_exchange_data( + sphlite_worker_ipc_t *ipc) +{ + if (ipc == 0) { + return 0; + } + return (sphlite_worker_data_exchange_t *)ipc->data_view; +} + +static int sphlite_worker_runtime_export_region( + sphlite_worker_data_exchange_t *data, int region_index, int capacity, + const sphlite_worker_runtime_reports_t *reports, int step_id) +{ + int count = 0; + int i; + int *ext_ids = 0; + int *internal_indices = 0; + int *phases = 0; + int *statuses = 0; + int *materials = 0; + int *sections = 0; + double *scalars = 0; + double *vectors = 0; + int ierr = -1; + + if (capacity <= 0) { + return 0; + } + ext_ids = (int *)calloc((size_t)capacity, sizeof(int)); + internal_indices = (int *)calloc((size_t)capacity, sizeof(int)); + phases = (int *)calloc((size_t)capacity, sizeof(int)); + statuses = (int *)calloc((size_t)capacity, sizeof(int)); + materials = (int *)calloc((size_t)capacity, sizeof(int)); + sections = (int *)calloc((size_t)capacity, sizeof(int)); + scalars = (double *)calloc((size_t)(7 * capacity), sizeof(double)); + vectors = (double *)calloc((size_t)(9 * capacity), sizeof(double)); + if (ext_ids == 0 || internal_indices == 0 || phases == 0 || + statuses == 0 || materials == 0 || sections == 0 || + scalars == 0 || vectors == 0) { + goto cleanup; + } + ierr = sphlite_coupling_export_particles(region_index, capacity, &count, + ext_ids, internal_indices, phases, statuses, materials, sections, + scalars, vectors); + if (ierr != 0) { + goto cleanup; + } + for (i = 0; i < count; ++i) { + sphlite_worker_particle_record_t record; + double h = scalars[6 + 7 * i]; + sphlite_worker_particle_record_clear(&record); + record.particle_id_ext = (long long)ext_ids[i]; + record.export_index = i + 1; + record.internal_index = internal_indices[i]; + record.phase = phases[i]; + record.status = statuses[i]; + record.material_id = materials[i]; + record.section_id = sections[i]; + record.mass = scalars[0 + 7 * i]; + record.volume = scalars[1 + 7 * i]; + record.density = scalars[2 + 7 * i]; + record.pressure = scalars[3 + 7 * i]; + record.h = h; + record.contact_radius = h > 0.0 ? 2.0 * h : 0.0; + record.sound_speed = 1.0; + record.x[0] = vectors[0 + 3 * (0 + 3 * i)]; + record.x[1] = vectors[1 + 3 * (0 + 3 * i)]; + record.x[2] = vectors[2 + 3 * (0 + 3 * i)]; + record.v[0] = vectors[0 + 3 * (1 + 3 * i)]; + record.v[1] = vectors[1 + 3 * (1 + 3 * i)]; + record.v[2] = vectors[2 + 3 * (1 + 3 * i)]; + record.valid_flags = SPHLITE_WORKER_VALID_POSITION | + SPHLITE_WORKER_VALID_VELOCITY | + SPHLITE_WORKER_VALID_PRESSURE | + SPHLITE_WORKER_VALID_DENSITY | + SPHLITE_WORKER_VALID_SOUND_SPEED; + (void)sphlite_worker_particle_block_add(data, &record); + sphlite_worker_runtime_reports_particle(reports, step_id, + region_index, &record); + } + +cleanup: + free(ext_ids); + free(internal_indices); + free(phases); + free(statuses); + free(materials); + free(sections); + free(scalars); + free(vectors); + return ierr; +} + +int sphlite_worker_runtime_export_particles( + sphlite_worker_ipc_t *ipc, + const sphlite_worker_runtime_reports_t *reports, int step_id) +{ + sphlite_worker_data_exchange_t *data = + sphlite_worker_runtime_exchange_data(ipc); + int region_count = 0; + int region_index; + int ierr; + + ierr = sphlite_coupling_get_region_count(®ion_count); + if (ierr != 0 || data == 0) { + return ierr; + } + data->particle_header.version = SPHLITE_WORKER_PARTICLE_BLOCK_VERSION; + data->particle_header.capacity = SPHLITE_WORKER_MAX_PARTICLE_RECORDS; + data->particle_header.count = 0; + data->particle_header.rejected_count = 0; + data->particle_header.nonfinite_count = 0; + for (region_index = 1; region_index <= region_count; ++region_index) { + char name[128]; + int region_type = 0; + int export_mode = 0; + int import_mode = 0; + int enabled = 0; + int particle_count = 0; + int facet_count = 0; + ierr = sphlite_coupling_get_region_info(region_index, name, + (int)sizeof(name), ®ion_type, &export_mode, &import_mode, + &enabled, &particle_count, &facet_count); + if (ierr != 0) { + return ierr; + } + if (enabled && particle_count > 0) { + ierr = sphlite_worker_runtime_export_region(data, region_index, + particle_count, reports, step_id); + if (ierr != 0) { + return ierr; + } + } + } + return 0; +} + +int sphlite_worker_runtime_import_forces( + sphlite_worker_ipc_t *ipc, + const sphlite_worker_runtime_reports_t *reports, int step_id) +{ + sphlite_worker_data_exchange_t *data = + sphlite_worker_runtime_exchange_data(ipc); + int region_count = 0; + int valid_count = 0; + int contact_count = 0; + int contact_state_mode = 0; + int load_mode = 0; + int distribution_mode = 0; + int api_step = step_id > 0 ? step_id : 0; + int i; + int *indices = 0; + int *contact_ids = 0; + double *forces = 0; + double *normals = 0; + double *gaps = 0; + double *penetrations = 0; + double *contact_pressures = 0; + int ierr; + + if (data == 0) { + return sphlite_coupling_clear_imports(); + } + if (data->force_header.version != SPHLITE_WORKER_FORCE_BLOCK_VERSION) { + return -1; + } + ierr = sphlite_coupling_get_region_count(®ion_count); + if (ierr != 0) { + return ierr; + } + if (region_count <= 0 || data->force_header.count <= 0) { + return sphlite_coupling_clear_imports(); + } + if (sphlite_worker_force_block_analyze(data, step_id, &valid_count, + &contact_count) != 0) { + return -1; + } + for (i = 0; i < data->force_header.count; ++i) { + sphlite_worker_runtime_reports_force(reports, step_id, 1, + &data->forces[i]); + } + if (valid_count <= 0) { + return sphlite_coupling_clear_imports(); + } + indices = (int *)calloc((size_t)valid_count, sizeof(int)); + forces = (double *)calloc((size_t)(3 * valid_count), sizeof(double)); + if (contact_count > 0) { + contact_ids = (int *)calloc((size_t)contact_count, sizeof(int)); + normals = (double *)calloc((size_t)(3 * contact_count), + sizeof(double)); + gaps = (double *)calloc((size_t)contact_count, sizeof(double)); + penetrations = (double *)calloc((size_t)contact_count, + sizeof(double)); + contact_pressures = (double *)calloc((size_t)contact_count, + sizeof(double)); + } + if (indices == 0 || forces == 0 || + (contact_count > 0 && (contact_ids == 0 || normals == 0 || + gaps == 0 || penetrations == 0 || contact_pressures == 0))) { + free(indices); + free(forces); + free(contact_ids); + free(normals); + free(gaps); + free(penetrations); + free(contact_pressures); + return -1; + } + valid_count = 0; + contact_count = 0; + for (i = 0; i < data->force_header.count; ++i) { + sphlite_worker_force_record_t *record = &data->forces[i]; + if (record->reject_reason != SPHLITE_WORKER_REJECT_NONE) { + continue; + } + indices[valid_count] = record->export_index > 0 ? + record->export_index : record->internal_index; + forces[0 + 3 * valid_count] = record->force[0]; + forces[1 + 3 * valid_count] = record->force[1]; + forces[2 + 3 * valid_count] = record->force[2]; + valid_count += 1; + if (sphlite_worker_runtime_contact_state_imported( + record->contact_state)) { + contact_ids[contact_count] = record->internal_index; + normals[0 + 3 * contact_count] = record->contact_normal[0]; + normals[1 + 3 * contact_count] = record->contact_normal[1]; + normals[2 + 3 * contact_count] = record->contact_normal[2]; + gaps[contact_count] = record->contact_gap; + penetrations[contact_count] = record->contact_penetration; + contact_pressures[contact_count] = record->contact_pressure; + if (api_step <= 0 && record->step_id > 0) { + api_step = record->step_id; + } + contact_count += 1; + } + } + if (valid_count > 0) { + ierr = sphlite_coupling_apply_particle_forces(1, valid_count, + indices, forces); + } else { + ierr = sphlite_coupling_clear_imports(); + } + if (ierr == 0 && contact_count > 0) { + ierr = sphlite_coupling_get_region_modes(1, &load_mode, + &distribution_mode, &contact_state_mode); + if (ierr == 0 && + contact_state_mode == SPHLITE_COUPLING_CONTACT_STATE_IMPORT) { + ierr = sphlite_coupling_apply_contact_state(1, contact_count, + contact_ids, normals, gaps, penetrations, contact_pressures, + api_step); + } + } + free(indices); + free(forces); + free(contact_ids); + free(normals); + free(gaps); + free(penetrations); + free(contact_pressures); + return ierr; +} diff --git a/src/app/sph_worker_runtime_exchange.h b/src/app/sph_worker_runtime_exchange.h new file mode 100644 index 0000000..632073b --- /dev/null +++ b/src/app/sph_worker_runtime_exchange.h @@ -0,0 +1,25 @@ +#ifndef SPHLITE_WORKER_RUNTIME_EXCHANGE_H +#define SPHLITE_WORKER_RUNTIME_EXCHANGE_H + +#include "sph_worker_blocks.h" +#include "sph_worker_ipc.h" +#include "sph_worker_runtime_reports.h" + +#ifdef __cplusplus +extern "C" { +#endif + +sphlite_worker_data_exchange_t *sphlite_worker_runtime_exchange_data( + sphlite_worker_ipc_t *ipc); +int sphlite_worker_runtime_export_particles( + sphlite_worker_ipc_t *ipc, + const sphlite_worker_runtime_reports_t *reports, int step_id); +int sphlite_worker_runtime_import_forces( + sphlite_worker_ipc_t *ipc, + const sphlite_worker_runtime_reports_t *reports, int step_id); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/app/sph_worker_runtime_reports.c b/src/app/sph_worker_runtime_reports.c new file mode 100644 index 0000000..e624c92 --- /dev/null +++ b/src/app/sph_worker_runtime_reports.c @@ -0,0 +1,140 @@ +#include "sph_worker_runtime_reports.h" + +#include "sph_worker_reports.h" + +#include + +static void sphlite_worker_runtime_reports_zero_totals( + sphlite_worker_log_record_t *record) +{ + record->total_force[0] = 0.0; + record->total_force[1] = 0.0; + record->total_force[2] = 0.0; + record->total_moment[0] = 0.0; + record->total_moment[1] = 0.0; + record->total_moment[2] = 0.0; +} + +void sphlite_worker_runtime_reports_init( + sphlite_worker_runtime_reports_t *reports, + const sphlite_worker_options_t *options) +{ + if (reports == 0) { + return; + } + (void)memset(reports, 0, sizeof(*reports)); + if (options == 0) { + return; + } + if (sphlite_worker_report_path(reports->log_path, + SPHLITE_WORKER_REPORT_PATH_CAPACITY, options->log_path, + SPHLITE_WORKER_REPORT_LOG) != 0) { + return; + } + if (sphlite_worker_report_path(reports->particle_path, + SPHLITE_WORKER_REPORT_PATH_CAPACITY, options->log_path, + SPHLITE_WORKER_REPORT_PARTICLE) != 0) { + return; + } + if (sphlite_worker_report_path(reports->force_path, + SPHLITE_WORKER_REPORT_PATH_CAPACITY, options->log_path, + SPHLITE_WORKER_REPORT_FORCE) != 0) { + return; + } + reports->enabled = 1; +} + +void sphlite_worker_runtime_reports_prepare( + const sphlite_worker_runtime_reports_t *reports) +{ + if (reports == 0 || !reports->enabled) { + return; + } + (void)sphlite_worker_report_write_header(reports->log_path, + SPHLITE_WORKER_REPORT_LOG); + (void)sphlite_worker_report_write_header(reports->particle_path, + SPHLITE_WORKER_REPORT_PARTICLE); + (void)sphlite_worker_report_write_header(reports->force_path, + SPHLITE_WORKER_REPORT_FORCE); +} + +void sphlite_worker_runtime_reports_log( + const sphlite_worker_runtime_reports_t *reports, + const sphlite_worker_options_t *options, + const sphlite_worker_ipc_t *ipc, + const sphlite_worker_data_exchange_t *data, + int command_id, int step_id, int ack_sequence, int worker_state, + int exported_facets, int error_code, const char *error_message) +{ + sphlite_worker_log_record_t record; + char line[1024]; + + if (reports == 0 || !reports->enabled || options == 0) { + return; + } + sphlite_worker_log_record_clear(&record); + record.solver_id = options->solver_id; + record.case_file = options->case_file; + record.ipc_name = options->ipc_name; + record.command_block = ipc == 0 ? "" : ipc->command_block; + record.data_prefix = ipc == 0 ? "" : ipc->data_prefix; + record.command_event = ipc == 0 ? "" : ipc->command_event; + record.done_event = ipc == 0 ? "" : ipc->done_event; + record.timeout_ms = options->timeout_ms; + record.worker_id = options->worker_id; + record.command_id = command_id; + record.step_id = step_id; + record.ack_sequence = ack_sequence; + record.worker_state = worker_state; + record.exported_facets = exported_facets; + record.error_code = error_code; + record.error_message = error_message; + sphlite_worker_runtime_reports_zero_totals(&record); + if (data != 0) { + record.exported_particles = data->particle_header.count; + record.received_forces = data->force_header.count; + record.nonfinite_particles = data->particle_header.nonfinite_count; + record.total_force[0] = data->force_header.total_force[0]; + record.total_force[1] = data->force_header.total_force[1]; + record.total_force[2] = data->force_header.total_force[2]; + record.total_moment[0] = data->force_header.total_moment[0]; + record.total_moment[1] = data->force_header.total_moment[1]; + record.total_moment[2] = data->force_header.total_moment[2]; + } + if (sphlite_worker_format_log_record(line, (int)sizeof(line), + &record) == 0) { + (void)sphlite_worker_report_append_line(reports->log_path, line); + } +} + +void sphlite_worker_runtime_reports_particle( + const sphlite_worker_runtime_reports_t *reports, + int step_id, int region_index, + const sphlite_worker_particle_record_t *record) +{ + char line[1024]; + + if (reports == 0 || !reports->enabled) { + return; + } + if (sphlite_worker_format_particle_record(line, (int)sizeof(line), + step_id, region_index, record) == 0) { + (void)sphlite_worker_report_append_line(reports->particle_path, line); + } +} + +void sphlite_worker_runtime_reports_force( + const sphlite_worker_runtime_reports_t *reports, + int step_id, int region_index, + const sphlite_worker_force_record_t *record) +{ + char line[1024]; + + if (reports == 0 || !reports->enabled) { + return; + } + if (sphlite_worker_format_force_record(line, (int)sizeof(line), + step_id, region_index, record) == 0) { + (void)sphlite_worker_report_append_line(reports->force_path, line); + } +} diff --git a/src/app/sph_worker_runtime_reports.h b/src/app/sph_worker_runtime_reports.h new file mode 100644 index 0000000..e004cf9 --- /dev/null +++ b/src/app/sph_worker_runtime_reports.h @@ -0,0 +1,45 @@ +#ifndef SPHLITE_WORKER_RUNTIME_REPORTS_H +#define SPHLITE_WORKER_RUNTIME_REPORTS_H + +#include "sph_worker_blocks.h" +#include "sph_worker_cli.h" +#include "sph_worker_ipc.h" +#include "sph_worker_reports.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct sphlite_worker_runtime_reports_t { + char log_path[SPHLITE_WORKER_REPORT_PATH_CAPACITY]; + char particle_path[SPHLITE_WORKER_REPORT_PATH_CAPACITY]; + char force_path[SPHLITE_WORKER_REPORT_PATH_CAPACITY]; + int enabled; +} sphlite_worker_runtime_reports_t; + +void sphlite_worker_runtime_reports_init( + sphlite_worker_runtime_reports_t *reports, + const sphlite_worker_options_t *options); +void sphlite_worker_runtime_reports_prepare( + const sphlite_worker_runtime_reports_t *reports); +void sphlite_worker_runtime_reports_log( + const sphlite_worker_runtime_reports_t *reports, + const sphlite_worker_options_t *options, + const sphlite_worker_ipc_t *ipc, + const sphlite_worker_data_exchange_t *data, + int command_id, int step_id, int ack_sequence, int worker_state, + int exported_facets, int error_code, const char *error_message); +void sphlite_worker_runtime_reports_particle( + const sphlite_worker_runtime_reports_t *reports, + int step_id, int region_index, + const sphlite_worker_particle_record_t *record); +void sphlite_worker_runtime_reports_force( + const sphlite_worker_runtime_reports_t *reports, + int step_id, int region_index, + const sphlite_worker_force_record_t *record); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/core/sph_precision.f90 b/src/core/sph_precision.f90 index b5cd25e..99b861c 100644 --- a/src/core/sph_precision.f90 +++ b/src/core/sph_precision.f90 @@ -4,7 +4,7 @@ module sph_precision integer, parameter :: rk = selected_real_kind(12, 100) integer, parameter :: SPH_VERSION_MAJOR = 0 integer, parameter :: SPH_VERSION_MINOR = 8 - integer, parameter :: SPH_VERSION_PATCH = 2 + integer, parameter :: SPH_VERSION_PATCH = 3 integer, parameter :: SPH_NDIM = 3 integer, parameter :: SPH_ERROR_MESSAGE_LEN = 256 integer, parameter :: SPH_PATH_LEN = 1024 diff --git a/src/database/sph_database.f90 b/src/database/sph_database.f90 index 130e9d4..7a0c8a9 100644 --- a/src/database/sph_database.f90 +++ b/src/database/sph_database.f90 @@ -186,6 +186,13 @@ module sph_database integer :: coupling_region_particles(SPH_MAX_SET_MEMBERS,SPH_MAX_REGIONS) integer :: coupling_region_disabled_count = 0 + integer :: cclite_worker_enabled = 0 + character(len=SPH_NAME_LEN) :: cclite_region_name = 'ALL' + integer :: cclite_export_radius = 1 + integer :: cclite_export_sound_speed = 1 + integer :: cclite_accept_contact_state = 1 + integer :: cclite_accept_boundary_state = 0 + contains subroutine sph_db_allocate(count, ierr) @@ -344,6 +351,12 @@ contains coupling_region_particle_count = 0 coupling_region_particles = 0 coupling_region_disabled_count = 0 + cclite_worker_enabled = 0 + cclite_region_name = 'ALL' + cclite_export_radius = 1 + cclite_export_sound_speed = 1 + cclite_accept_contact_state = 1 + cclite_accept_boundary_state = 0 end subroutine sph_db_clear_metadata subroutine sph_db_clear_water_diagnostics() @@ -726,6 +739,39 @@ contains if (n > 0) element_conn(1:n,element_count) = conn_values(1:n) end subroutine sph_db_add_element + subroutine sph_db_set_cclite_options(worker_enabled, region_name, & + export_radius, export_sound_speed, accept_contact_state, & + accept_boundary_state, ierr) + integer, intent(in) :: worker_enabled + character(len=*), intent(in) :: region_name + integer, intent(in) :: export_radius + integer, intent(in) :: export_sound_speed + integer, intent(in) :: accept_contact_state + integer, intent(in) :: accept_boundary_state + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + if ((worker_enabled < 0 .or. worker_enabled > 1) .or. & + (export_radius < 0 .or. export_radius > 1) .or. & + (export_sound_speed < 0 .or. export_sound_speed > 1) .or. & + (accept_contact_state < 0 .or. accept_contact_state > 1) .or. & + (accept_boundary_state < 0 .or. accept_boundary_state > 1)) then + call sph_error_set(SPH_ERROR_DATABASE, 'invalid CCLite option flag') + ierr = SPH_ERROR_DATABASE + return + end if + cclite_worker_enabled = worker_enabled + if (len_trim(region_name) > 0) then + cclite_region_name = adjustl(region_name) + else + cclite_region_name = 'ALL' + end if + cclite_export_radius = export_radius + cclite_export_sound_speed = export_sound_speed + cclite_accept_contact_state = accept_contact_state + cclite_accept_boundary_state = accept_boundary_state + end subroutine sph_db_set_cclite_options + subroutine sph_db_add_coupling_region(name, set_name, region_type, & export_mode, import_mode, load_mode, distribution_mode, & contact_state_mode, enabled, surface_name, phase_filter, & diff --git a/src/input/sph_input_reader.f90 b/src/input/sph_input_reader.f90 index a2780c0..8a7548b 100644 --- a/src/input/sph_input_reader.f90 +++ b/src/input/sph_input_reader.f90 @@ -20,6 +20,7 @@ module sph_input_reader sph_db_allocate, sph_db_free, sph_db_set_node, sph_db_add_material, & sph_db_add_section, sph_db_add_nset, sph_db_add_elset, & sph_db_add_element, sph_db_add_coupling_region, & + sph_db_set_cclite_options, & sph_db_apply_sections_to_particles, sph_db_build_coupling_regions use sph_database, only: sph_db_set_material_density, material_count, & material_name, material_type @@ -366,6 +367,8 @@ contains call sph_input_parse_output_control(line, ierr) else if (index(upper_line, 'COUPLING REGION') > 0) then call sph_input_parse_coupling_region(line, ierr) + else if (index(upper_line, 'CCLITE') > 0) then + call sph_input_parse_cclite_options(line, ierr) else if (index(upper_line, 'EOS') > 0) then call sph_input_parse_eos(line, ierr) else if (index(upper_line, 'VISCOSITY') > 0) then @@ -1115,6 +1118,78 @@ contains end if end subroutine sph_input_parse_output_control + subroutine sph_input_parse_cclite_options(line, ierr) + character(len=*), intent(in) :: line + integer, intent(out) :: ierr + character(len=SPH_INPUT_FIELD_LEN) :: value + character(len=SPH_INPUT_FIELD_LEN) :: region_name + logical :: worker_enabled + logical :: export_radius + logical :: export_sound_speed + logical :: accept_contact_state + logical :: accept_boundary_state + integer :: worker_flag + integer :: radius_flag + integer :: sound_speed_flag + integer :: contact_state_flag + integer :: boundary_state_flag + + ierr = SPH_SUCCESS + worker_enabled = .true. + export_radius = .true. + export_sound_speed = .true. + accept_contact_state = .true. + accept_boundary_state = .false. + region_name = 'ALL' + + call sph_input_get_option(line, 'WORKER', value) + if (len_trim(value) > 0) then + call sph_input_parse_logical_value(value, worker_enabled, & + 'invalid CCLite WORKER option', ierr) + if (ierr /= SPH_SUCCESS) return + end if + call sph_input_get_option(line, 'REGION', value) + if (len_trim(value) > 0) region_name = value + + call sph_input_get_option(line, 'EXPORT_RADIUS', value) + if (len_trim(value) > 0) then + call sph_input_parse_logical_value(value, export_radius, & + 'invalid CCLite EXPORT_RADIUS option', ierr) + if (ierr /= SPH_SUCCESS) return + end if + call sph_input_get_option(line, 'EXPORT_SOUND_SPEED', value) + if (len_trim(value) > 0) then + call sph_input_parse_logical_value(value, export_sound_speed, & + 'invalid CCLite EXPORT_SOUND_SPEED option', ierr) + if (ierr /= SPH_SUCCESS) return + end if + call sph_input_get_option(line, 'ACCEPT_CONTACT_STATE', value) + if (len_trim(value) > 0) then + call sph_input_parse_logical_value(value, accept_contact_state, & + 'invalid CCLite ACCEPT_CONTACT_STATE option', ierr) + if (ierr /= SPH_SUCCESS) return + end if + call sph_input_get_option(line, 'ACCEPT_BOUNDARY_STATE', value) + if (len_trim(value) > 0) then + call sph_input_parse_logical_value(value, accept_boundary_state, & + 'invalid CCLite ACCEPT_BOUNDARY_STATE option', ierr) + if (ierr /= SPH_SUCCESS) return + end if + + worker_flag = 0 + radius_flag = 0 + sound_speed_flag = 0 + contact_state_flag = 0 + boundary_state_flag = 0 + if (worker_enabled) worker_flag = 1 + if (export_radius) radius_flag = 1 + if (export_sound_speed) sound_speed_flag = 1 + if (accept_contact_state) contact_state_flag = 1 + if (accept_boundary_state) boundary_state_flag = 1 + call sph_db_set_cclite_options(worker_flag, region_name, radius_flag, & + sound_speed_flag, contact_state_flag, boundary_state_flag, ierr) + end subroutine sph_input_parse_cclite_options + subroutine sph_input_parse_coupling_region(line, ierr) character(len=*), intent(in) :: line integer, intent(out) :: ierr diff --git a/tests/app/test_worker_blocks.c b/tests/app/test_worker_blocks.c new file mode 100644 index 0000000..9dbb594 --- /dev/null +++ b/tests/app/test_worker_blocks.c @@ -0,0 +1,138 @@ +#include "sph_worker_blocks.h" + +#include + +static int fail(const char *message) +{ + fprintf(stderr, "%s\n", message); + return 1; +} + +static void fill_particle(sphlite_worker_particle_record_t *record) +{ + sphlite_worker_particle_record_clear(record); + record->particle_id_ext = 10; + record->export_index = 1; + record->internal_index = 1; + record->phase = 1; + record->status = 0; + record->material_id = 1; + record->section_id = 1; + record->x[0] = 0.1; + record->v[1] = 0.2; + record->mass = 1.0; + record->density = 1000.0; + record->volume = 0.001; + record->h = 0.1; + record->contact_radius = 0.2; + record->pressure = 0.0; + record->sound_speed = 1500.0; + record->valid_flags = SPHLITE_WORKER_VALID_POSITION | + SPHLITE_WORKER_VALID_VELOCITY | + SPHLITE_WORKER_VALID_DENSITY | + SPHLITE_WORKER_VALID_PRESSURE | + SPHLITE_WORKER_VALID_SOUND_SPEED; +} + +static void fill_force(sphlite_worker_force_record_t *record) +{ + sphlite_worker_force_record_clear(record); + record->particle_id_ext = 10; + record->export_index = 1; + record->internal_index = 1; + record->force[0] = 1.0; + record->moment[2] = 0.5; + record->contact_normal[2] = 1.0; + record->contact_gap = 0.01; + record->contact_penetration = 0.02; + record->contact_pressure = 3.0; + record->source_id = 7; + record->pair_id = 8; + record->load_mode = 1; + record->contact_state = SPHLITE_WORKER_CONTACT_ACTIVE; + record->step_id = 2; + record->valid_flags = SPHLITE_WORKER_VALID_MOMENT | + SPHLITE_WORKER_VALID_NORMAL; +} + +int main(void) +{ + sphlite_worker_data_exchange_t data; + sphlite_worker_particle_record_t particle; + sphlite_worker_force_record_t force; + int valid_count = 0; + int contact_count = 0; + int reason = -1; + + sphlite_worker_data_exchange_clear(&data); + if (data.particle_header.version != SPHLITE_WORKER_PARTICLE_BLOCK_VERSION || + data.force_header.version != SPHLITE_WORKER_FORCE_BLOCK_VERSION || + data.particle_header.capacity != SPHLITE_WORKER_MAX_PARTICLE_RECORDS || + data.force_header.capacity != SPHLITE_WORKER_MAX_FORCE_RECORDS) { + return fail("block header initialization mismatch"); + } + + fill_particle(&particle); + if (sphlite_worker_particle_record_validate(&particle, &reason) != 0 || + reason != SPHLITE_WORKER_REJECT_NONE) { + return fail("valid particle was rejected"); + } + if (sphlite_worker_particle_block_add(&data, &particle) != 0 || + data.particle_header.count != 1) { + return fail("particle add failed"); + } + particle.mass = -1.0; + if (sphlite_worker_particle_record_validate(&particle, &reason) == 0 || + reason != SPHLITE_WORKER_REJECT_INVALID_WEIGHT) { + return fail("invalid particle mass was not rejected"); + } + if (sphlite_worker_particle_block_add(&data, &particle) == 0 || + data.particle_header.rejected_count != 1) { + return fail("invalid particle add diagnostics failed"); + } + + fill_force(&force); + if (sphlite_worker_force_record_validate(&force, &reason) != 0 || + reason != SPHLITE_WORKER_REJECT_NONE) { + return fail("valid force was rejected"); + } + if (sphlite_worker_force_block_add(&data, &force) != 0 || + data.force_header.count != 1) { + return fail("force add failed"); + } + fill_force(&force); + force.export_index = 2; + force.internal_index = 2; + force.particle_id_ext = 11; + force.step_id = 1; + if (sphlite_worker_force_block_add(&data, &force) != 0) { + return fail("stale force setup failed"); + } + fill_force(&force); + if (sphlite_worker_force_block_add(&data, &force) != 0) { + return fail("repeated force setup failed"); + } + if (sphlite_worker_force_block_analyze(&data, 2, &valid_count, + &contact_count) != 0 || valid_count != 1 || contact_count != 1) { + return fail("force diagnostics analysis failed"); + } + if (data.force_header.stale_count != 1 || + data.force_header.repeated_count != 1 || + data.force_header.rejected_count != 2) { + return fail("force rejection diagnostics mismatch"); + } + if (data.force_header.total_force[0] != 1.0 || + data.force_header.total_moment[2] != 0.5) { + return fail("force total diagnostics mismatch"); + } + force.force[1] = 0.0 / 0.0; + if (sphlite_worker_force_record_validate(&force, &reason) == 0 || + reason != SPHLITE_WORKER_REJECT_NONFINITE_FORCE) { + return fail("nonfinite force was not rejected"); + } + if (sphlite_worker_force_block_add(&data, &force) == 0 || + data.force_header.nonfinite_count != 1) { + return fail("nonfinite force diagnostics failed"); + } + return 0; +} diff --git a/tests/app/test_worker_cli.c b/tests/app/test_worker_cli.c index 2f4ab7a..919b9ee 100644 --- a/tests/app/test_worker_cli.c +++ b/tests/app/test_worker_cli.c @@ -27,6 +27,10 @@ int main(void) sphlite_worker_options_t options; char message[256]; char *plain[] = {"sphlite", "model.inp", "--run"}; + char *capabilities[] = {"sphlite", "--cclite-capabilities"}; + char *capabilities_conflict[] = { + "sphlite", "--cclite-capabilities", "--cclite-worker" + }; char *valid_min[] = { "sphlite", "--cclite-worker", "--case", "case.inp", "--ipc-name", "local-ipc" @@ -54,6 +58,18 @@ int main(void) if (sphlite_worker_args_requested(3, plain)) { return fail("ordinary CLI was detected as worker mode"); } + if (sphlite_worker_capabilities_requested(3, plain)) { + return fail("ordinary CLI was detected as capabilities mode"); + } + if (!sphlite_worker_capabilities_requested(2, capabilities)) { + return fail("capabilities CLI was not detected"); + } + if (sphlite_worker_capabilities_main(2, capabilities) != 0) { + return fail("capabilities CLI main failed"); + } + if (sphlite_worker_capabilities_main(3, capabilities_conflict) == 0) { + return fail("capabilities conflict was accepted"); + } if (!sphlite_worker_args_requested(6, valid_min)) { return fail("worker CLI was not detected"); } diff --git a/tests/app/test_worker_ipc.c b/tests/app/test_worker_ipc.c index 90fc524..31ea0bd 100644 --- a/tests/app/test_worker_ipc.c +++ b/tests/app/test_worker_ipc.c @@ -83,6 +83,17 @@ int main(void) check_int(ipc.command_sequence, 7, "ack sequence") != 0) { return 1; } + { + int sequence = 0; + int command = 0; + int step_id = 0; + double dt = 0.0; + if (sphlite_worker_ipc_read_command(&ipc, &sequence, &command, + &dt, &step_id, &error_code) == 0 || + error_code != SPHLITE_WORKER_ERROR_UNSUPPORTED) { + return fail("mock command read did not report unsupported"); + } + } if (sphlite_worker_ipc_reset_event(&ipc, &error_code) == 0 || error_code != SPHLITE_WORKER_ERROR_CONFLICT || @@ -93,6 +104,13 @@ int main(void) error_code != SPHLITE_WORKER_ERROR_TIMEOUT) { return fail("wait timeout path failed"); } + if (sphlite_worker_ipc_close(&ipc) != 0 || ipc.opened != 0) { + return fail("IPC close failed"); + } + if (sphlite_worker_ipc_write_ready(&ipc, &error_code) == 0 || + error_code != SPHLITE_WORKER_ERROR_IPC) { + return fail("ready write after close did not fail"); + } if (sphlite_worker_ipc_init(&ipc, "", 0, 0) == 0) { return fail("empty IPC name was accepted"); } diff --git a/tests/app/test_worker_ipc_selftest.c b/tests/app/test_worker_ipc_selftest.c new file mode 100644 index 0000000..328cdec --- /dev/null +++ b/tests/app/test_worker_ipc_selftest.c @@ -0,0 +1,330 @@ +#include "sph_worker_blocks.h" +#include "sph_worker_ipc.h" +#include "sph_worker_runtime.h" + +#include +#include + +#ifdef _WIN32 +#define WIN32_LEAN_AND_MEAN +#include +#endif + +static int fail(const char *message) +{ + fprintf(stderr, "%s\n", message); + return 1; +} + +#ifdef _WIN32 +typedef struct worker_selftest_t { + sphlite_worker_options_t options; + char solver_id[16]; + char case_file[128]; + char ipc_name[128]; + char command_block[128]; + char data_block[128]; + char log_path[256]; + char worker_id[64]; + HANDLE command_mapping; + HANDLE data_mapping; + HANDLE command_event; + HANDLE done_event; + sphlite_worker_command_block_t *command; + sphlite_worker_data_exchange_t *data; + HANDLE thread; + DWORD thread_id; + int worker_result; +} worker_selftest_t; + +static DWORD WINAPI worker_thread_main(LPVOID user_data) +{ + worker_selftest_t *selftest = (worker_selftest_t *)user_data; + selftest->worker_result = sphlite_worker_run_real_ipc(&selftest->options); + return (DWORD)selftest->worker_result; +} + +static void selftest_close(worker_selftest_t *selftest) +{ + if (selftest->thread != 0) (void)CloseHandle(selftest->thread); + if (selftest->command != 0) (void)UnmapViewOfFile(selftest->command); + if (selftest->data != 0) (void)UnmapViewOfFile(selftest->data); + if (selftest->command_mapping != 0) { + (void)CloseHandle(selftest->command_mapping); + } + if (selftest->data_mapping != 0) { + (void)CloseHandle(selftest->data_mapping); + } + if (selftest->command_event != 0) (void)CloseHandle(selftest->command_event); + if (selftest->done_event != 0) (void)CloseHandle(selftest->done_event); +} + +static int selftest_init(worker_selftest_t *selftest, const char *suffix, + int timeout_ms) +{ + DWORD pid = GetCurrentProcessId(); + (void)memset(selftest, 0, sizeof(*selftest)); + (void)snprintf(selftest->solver_id, sizeof(selftest->solver_id), "SPH"); + (void)snprintf(selftest->case_file, sizeof(selftest->case_file), + "tests/data/coupling_region_080.inp"); + (void)snprintf(selftest->ipc_name, sizeof(selftest->ipc_name), + "sphlite_selftest_%lu_%s", (unsigned long)pid, suffix); + (void)snprintf(selftest->command_block, sizeof(selftest->command_block), + "%s.command", selftest->ipc_name); + (void)snprintf(selftest->data_block, sizeof(selftest->data_block), + "%s.data", selftest->ipc_name); + (void)snprintf(selftest->log_path, sizeof(selftest->log_path), + "build-codex-unix/%s.log", selftest->ipc_name); + (void)snprintf(selftest->worker_id, sizeof(selftest->worker_id), + "selftest"); + + selftest->command_mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, 0, + PAGE_READWRITE, 0, sizeof(sphlite_worker_command_block_t), + selftest->command_block); + selftest->data_mapping = CreateFileMappingA(INVALID_HANDLE_VALUE, 0, + PAGE_READWRITE, 0, sizeof(sphlite_worker_data_exchange_t), + selftest->data_block); + if (selftest->command_mapping == 0 || selftest->data_mapping == 0) { + selftest_close(selftest); + return fail("self-test mapping creation failed"); + } + { + char command_event_name[128]; + char done_event_name[128]; + (void)snprintf(command_event_name, sizeof(command_event_name), + "%s.command_event", selftest->ipc_name); + (void)snprintf(done_event_name, sizeof(done_event_name), + "%s.done_event", selftest->ipc_name); + selftest->command_event = CreateEventA(0, FALSE, FALSE, + command_event_name); + selftest->done_event = CreateEventA(0, FALSE, FALSE, + done_event_name); + } + if (selftest->command_event == 0 || selftest->done_event == 0) { + selftest_close(selftest); + return fail("self-test event creation failed"); + } + selftest->command = (sphlite_worker_command_block_t *)MapViewOfFile( + selftest->command_mapping, FILE_MAP_ALL_ACCESS, 0, 0, + sizeof(sphlite_worker_command_block_t)); + selftest->data = (sphlite_worker_data_exchange_t *)MapViewOfFile( + selftest->data_mapping, FILE_MAP_ALL_ACCESS, 0, 0, + sizeof(sphlite_worker_data_exchange_t)); + if (selftest->command == 0 || selftest->data == 0) { + selftest_close(selftest); + return fail("self-test map view failed"); + } + (void)memset(selftest->command, 0, + sizeof(sphlite_worker_command_block_t)); + sphlite_worker_data_exchange_clear(selftest->data); + sphlite_worker_options_init(&selftest->options); + selftest->options.enabled = 1; + selftest->options.solver_id = selftest->solver_id; + selftest->options.case_file = selftest->case_file; + selftest->options.ipc_name = selftest->ipc_name; + selftest->options.command_block = selftest->command_block; + selftest->options.data_prefix = selftest->data_block; + selftest->options.log_path = selftest->log_path; + selftest->options.timeout_ms = timeout_ms; + selftest->options.worker_id = selftest->worker_id; + return 0; +} + +static int selftest_start(worker_selftest_t *selftest) +{ + selftest->thread = CreateThread(0, 0, worker_thread_main, selftest, 0, + &selftest->thread_id); + if (selftest->thread == 0) { + return fail("self-test worker thread failed"); + } + if (WaitForSingleObject(selftest->done_event, 5000) != WAIT_OBJECT_0) { + return fail("self-test READY wait failed"); + } + if (selftest->command->worker_state != SPHLITE_WORKER_STATE_READY || + selftest->command->error_code != SPHLITE_WORKER_ERROR_OK) { + return fail("self-test READY state mismatch"); + } + return 0; +} + +static int selftest_send(worker_selftest_t *selftest, int sequence, + int command, int step_id, double dt, + int expected_state, int expected_error) +{ + selftest->command->version = SPHLITE_WORKER_COMMAND_BLOCK_VERSION; + selftest->command->sequence = sequence; + selftest->command->command = command; + selftest->command->step_id = step_id; + selftest->command->dt = dt; + if (!SetEvent(selftest->command_event)) { + return fail("self-test command signal failed"); + } + if (WaitForSingleObject(selftest->done_event, 5000) != WAIT_OBJECT_0) { + return fail("self-test DONE wait failed"); + } + if (selftest->command->ack_sequence != sequence || + selftest->command->worker_state != expected_state || + selftest->command->error_code != expected_error) { + fprintf(stderr, "ack=%d state=%d error=%d\n", + selftest->command->ack_sequence, + selftest->command->worker_state, + selftest->command->error_code); + return fail("self-test command result mismatch"); + } + return 0; +} + +static int selftest_empty_coupling_step(worker_selftest_t *selftest, + int *sequence) +{ + selftest->data->force_header.version = SPHLITE_WORKER_FORCE_BLOCK_VERSION; + selftest->data->force_header.count = 0; + *sequence += 1; + if (selftest_send(selftest, *sequence, SPHLITE_WORKER_COMMAND_IMPORT_LOADS, + *sequence, 0.0, SPHLITE_WORKER_STATE_DONE, + SPHLITE_WORKER_ERROR_OK) != 0) { + return 1; + } + *sequence += 1; + return selftest_send(selftest, *sequence, SPHLITE_WORKER_COMMAND_ADVANCE, + *sequence, 1.0e-9, SPHLITE_WORKER_STATE_DONE, + SPHLITE_WORKER_ERROR_OK); +} + +static int selftest_join(worker_selftest_t *selftest, int expected_result) +{ + DWORD code = 99; + if (WaitForSingleObject(selftest->thread, 5000) != WAIT_OBJECT_0) { + return fail("self-test worker join failed"); + } + if (!GetExitCodeThread(selftest->thread, &code) || + (int)code != expected_result || + selftest->worker_result != expected_result) { + return fail("self-test worker result mismatch"); + } + return 0; +} + +static int check_command_selftest(void) +{ + worker_selftest_t selftest; + int sequence = 0; + int i; + if (selftest_init(&selftest, "commands", 5000) != 0) return 1; + if (selftest_start(&selftest) != 0) { + selftest_close(&selftest); + return 1; + } + sequence = 1; + if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_INIT, 0, 0.0, + SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) return 1; + sequence = 2; + if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_EXPORT_INTERFACE, + 0, 0.0, SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) { + return 1; + } + if (selftest.data->particle_header.count != 0) { + return fail("self-test empty export was not empty"); + } + sequence = 3; + if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_READ_INPUT, 0, + 0.0, SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) { + return 1; + } + sequence = 4; + if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_BUILD_MODEL, 0, + 0.0, SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) { + return 1; + } + if (selftest_empty_coupling_step(&selftest, &sequence) != 0) { + return 1; + } + for (i = 0; i < 100; ++i) { + if (selftest_empty_coupling_step(&selftest, &sequence) != 0) { + return 1; + } + } + sequence += 1; + if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_EXPORT_INTERFACE, + sequence, 0.0, SPHLITE_WORKER_STATE_DONE, + SPHLITE_WORKER_ERROR_OK) != 0) { + return 1; + } + if (selftest.data->particle_header.count <= 0) { + return fail("self-test fixed particle export was empty"); + } + sequence += 1; + if (selftest_send(&selftest, sequence, SPHLITE_WORKER_COMMAND_STOP, + sequence, 0.0, + SPHLITE_WORKER_STATE_STOPPED, SPHLITE_WORKER_ERROR_OK) != 0) { + return 1; + } + if (selftest_join(&selftest, 0) != 0) return 1; + selftest_close(&selftest); + return 0; +} + +static int check_invalid_input_selftest(void) +{ + worker_selftest_t selftest; + if (selftest_init(&selftest, "invalid", 5000) != 0) return 1; + (void)snprintf(selftest.case_file, sizeof(selftest.case_file), + "tests/data/does_not_exist_for_worker.inp"); + if (selftest_start(&selftest) != 0) { + selftest_close(&selftest); + return 1; + } + if (selftest_send(&selftest, 1, SPHLITE_WORKER_COMMAND_INIT, 0, 0.0, + SPHLITE_WORKER_STATE_DONE, SPHLITE_WORKER_ERROR_OK) != 0) { + selftest_close(&selftest); + return 1; + } + if (selftest_send(&selftest, 2, SPHLITE_WORKER_COMMAND_READ_INPUT, 0, + 0.0, SPHLITE_WORKER_STATE_ERROR, + SPHLITE_WORKER_ERROR_INTERNAL) != 0) { + selftest_close(&selftest); + return 1; + } + if (selftest_join(&selftest, 2) != 0) { + selftest_close(&selftest); + return 1; + } + selftest_close(&selftest); + return 0; +} + +static int check_timeout_selftest(void) +{ + worker_selftest_t selftest; + if (selftest_init(&selftest, "timeout", 100) != 0) return 1; + if (selftest_start(&selftest) != 0) { + selftest_close(&selftest); + return 1; + } + if (WaitForSingleObject(selftest.done_event, 5000) != WAIT_OBJECT_0) { + selftest_close(&selftest); + return fail("self-test timeout DONE wait failed"); + } + if (selftest.command->worker_state != SPHLITE_WORKER_STATE_ERROR || + selftest.command->error_code != SPHLITE_WORKER_ERROR_TIMEOUT) { + selftest_close(&selftest); + return fail("self-test timeout state mismatch"); + } + if (selftest_join(&selftest, 2) != 0) { + selftest_close(&selftest); + return 1; + } + selftest_close(&selftest); + return 0; +} +#endif + +int main(void) +{ +#ifdef _WIN32 + if (check_command_selftest() != 0) return 1; + if (check_invalid_input_selftest() != 0) return 1; + if (check_timeout_selftest() != 0) return 1; +#endif + return 0; +} diff --git a/tests/app/test_worker_reports.c b/tests/app/test_worker_reports.c index 54f00a4..6874545 100644 --- a/tests/app/test_worker_reports.c +++ b/tests/app/test_worker_reports.c @@ -18,6 +18,10 @@ static int contains(const char *text, const char *needle) int main(void) { char record[512]; + char path[512]; + sphlite_worker_log_record_t log_record; + sphlite_worker_particle_record_t particle; + sphlite_worker_force_record_t force; if (strcmp(sphlite_worker_report_filename(SPHLITE_WORKER_REPORT_LOG), "sphlite_cclite_worker.log") != 0) { return fail("worker log filename mismatch"); @@ -26,8 +30,16 @@ int main(void) "command_block") || !contains(sphlite_worker_report_header(SPHLITE_WORKER_REPORT_LOG), "ack_sequence") || + !contains(sphlite_worker_report_header(SPHLITE_WORKER_REPORT_LOG), + "total_fx") || !contains(sphlite_worker_report_header(SPHLITE_WORKER_REPORT_PARTICLE), "external_id") || + !contains(sphlite_worker_report_header(SPHLITE_WORKER_REPORT_PARTICLE), + "internal_index") || + !contains(sphlite_worker_report_header(SPHLITE_WORKER_REPORT_FORCE), + "contact_state") || + !contains(sphlite_worker_report_header(SPHLITE_WORKER_REPORT_PARTICLE), + "reject_reason") || !contains(sphlite_worker_report_header(SPHLITE_WORKER_REPORT_FORCE), "reject_reason")) { return fail("worker report header mismatch"); @@ -35,19 +47,88 @@ int main(void) if (!sphlite_worker_report_vtk_supported()) { return fail("VTU/PVD support was not advertised"); } - if (sphlite_worker_format_log_record(record, (int)sizeof(record), "SPH", - "cmd", "data", SPHLITE_WORKER_COMMAND_ADVANCE, 12, 44, - SPHLITE_WORKER_STATE_DONE, 3, 4, 5, 0, "ok") != 0) { + sphlite_worker_log_record_clear(&log_record); + log_record.solver_id = "SPH"; + log_record.case_file = "case.inp"; + log_record.ipc_name = "ipc"; + log_record.command_block = "cmd"; + log_record.data_prefix = "data"; + log_record.command_event = "cmd_evt"; + log_record.done_event = "done_evt"; + log_record.timeout_ms = 30; + log_record.worker_id = "worker"; + log_record.command_id = SPHLITE_WORKER_COMMAND_ADVANCE; + log_record.step_id = 12; + log_record.ack_sequence = 44; + log_record.worker_state = SPHLITE_WORKER_STATE_DONE; + log_record.exported_particles = 3; + log_record.exported_facets = 4; + log_record.received_forces = 5; + log_record.total_force[0] = 1.0; + log_record.total_force[1] = 2.0; + log_record.total_force[2] = 3.0; + log_record.total_moment[0] = 4.0; + log_record.total_moment[1] = 5.0; + log_record.total_moment[2] = 6.0; + log_record.error_message = "ok"; + if (sphlite_worker_format_log_record(record, (int)sizeof(record), + &log_record) != 0) { return fail("log record formatting failed"); } - if (!contains(record, "SPH,cmd,data") || + if (!contains(record, "SPH,case.inp,ipc,cmd,data,cmd_evt,done_evt") || !contains(record, ",44,DONE,") || - !contains(record, ",3,4,5,0,ok")) { + !contains(record, ",3,4,5,") || + !contains(record, ",0,ok")) { return fail("log record content mismatch"); } - if (sphlite_worker_format_log_record(record, 8, "SPH", "cmd", "data", - 1, 2, 3, SPHLITE_WORKER_STATE_DONE, 4, 5, 6, 0, "too-long") == 0) { + if (sphlite_worker_format_log_record(record, 8, &log_record) == 0) { return fail("small log record buffer was accepted"); } + if (sphlite_worker_report_path(path, (int)sizeof(path), + "build-codex-unix/worker_test.log", + SPHLITE_WORKER_REPORT_PARTICLE) != 0 || + !contains(path, "build-codex-unix/") || + !contains(path, "sphlite_cclite_particle_report.csv")) { + return fail("worker report path parsing failed"); + } + if (sphlite_worker_report_write_header(path, + SPHLITE_WORKER_REPORT_PARTICLE) != 0 || + sphlite_worker_report_append_line(path, "1,2,3") != 0) { + return fail("worker report file write failed"); + } + sphlite_worker_particle_record_clear(&particle); + particle.particle_id_ext = 12; + particle.export_index = 2; + particle.internal_index = 3; + particle.phase = 1; + particle.status = 0; + particle.material_id = 4; + particle.section_id = 5; + particle.x[0] = 1.0; + particle.v[2] = 2.0; + particle.reject_reason = SPHLITE_WORKER_REJECT_INVALID_WEIGHT; + if (sphlite_worker_format_particle_record(record, (int)sizeof(record), + 7, 2, &particle) != 0 || + !contains(record, "7,2,2,3,12,1,0,4,5") || + !contains(record, "invalid_weight")) { + return fail("particle record formatting failed"); + } + sphlite_worker_force_record_clear(&force); + force.particle_id_ext = 12; + force.export_index = 2; + force.internal_index = 3; + force.source_id = 8; + force.pair_id = 9; + force.force[0] = 3.0; + force.moment[1] = 4.0; + force.contact_state = SPHLITE_WORKER_CONTACT_ACTIVE; + force.reject_reason = SPHLITE_WORKER_REJECT_NONFINITE_FORCE; + if (sphlite_worker_format_force_record(record, (int)sizeof(record), + 7, 2, &force) != 0 || + !contains(record, "7,2,8,9,12,2,3") || + !contains(record, "active") || + !contains(record, "nonfinite_force")) { + return fail("force record formatting failed"); + } return 0; } diff --git a/tests/app/test_worker_runtime_reports.c b/tests/app/test_worker_runtime_reports.c new file mode 100644 index 0000000..e4a057c --- /dev/null +++ b/tests/app/test_worker_runtime_reports.c @@ -0,0 +1,77 @@ +#include "sph_worker_runtime_reports.h" + +#include +#include + +static int fail(const char *message) +{ + fprintf(stderr, "%s\n", message); + return 1; +} + +static void fill_options(sphlite_worker_options_t *options) +{ + sphlite_worker_options_init(options); + options->solver_id = "SPH"; + options->case_file = "case.inp"; + options->ipc_name = "ipc"; + options->log_path = "build-codex-unix/worker_runtime_report.log"; + options->worker_id = "worker"; +} + +static void fill_ipc(sphlite_worker_ipc_t *ipc) +{ + (void)sphlite_worker_ipc_init(ipc, "ipc", "cmd_block", "data_block"); +} + +int main(void) +{ + sphlite_worker_options_t options; + sphlite_worker_ipc_t ipc; + sphlite_worker_runtime_reports_t reports; + sphlite_worker_data_exchange_t data; + sphlite_worker_particle_record_t particle; + sphlite_worker_force_record_t force; + + fill_options(&options); + fill_ipc(&ipc); + sphlite_worker_runtime_reports_init(&reports, &options); + if (!reports.enabled || + strstr(reports.log_path, "worker_runtime_report.log") == 0 || + strstr(reports.particle_path, + "sphlite_cclite_particle_report.csv") == 0 || + strstr(reports.force_path, "sphlite_cclite_force_report.csv") == 0) { + return fail("runtime report path initialization failed"); + } + sphlite_worker_runtime_reports_prepare(&reports); + + sphlite_worker_data_exchange_clear(&data); + data.particle_header.count = 1; + data.particle_header.nonfinite_count = 2; + data.force_header.count = 3; + data.force_header.total_force[0] = 4.0; + data.force_header.total_moment[1] = 5.0; + sphlite_worker_runtime_reports_log(&reports, &options, &ipc, &data, + SPHLITE_WORKER_COMMAND_IMPORT_LOADS, 6, 7, + SPHLITE_WORKER_STATE_DONE, 0, SPHLITE_WORKER_ERROR_OK, "ok"); + + sphlite_worker_particle_record_clear(&particle); + particle.particle_id_ext = 10; + particle.export_index = 1; + particle.internal_index = 2; + particle.phase = 1; + particle.status = 0; + particle.material_id = 3; + particle.section_id = 4; + sphlite_worker_runtime_reports_particle(&reports, 6, 1, &particle); + + sphlite_worker_force_record_clear(&force); + force.particle_id_ext = 10; + force.export_index = 1; + force.internal_index = 2; + force.source_id = 3; + force.pair_id = 4; + force.contact_state = SPHLITE_WORKER_CONTACT_ACTIVE; + sphlite_worker_runtime_reports_force(&reports, 6, 1, &force); + return 0; +} diff --git a/tests/data/cclite_options_082.inp b/tests/data/cclite_options_082.inp new file mode 100644 index 0000000..3b40fdb --- /dev/null +++ b/tests/data/cclite_options_082.inp @@ -0,0 +1,3 @@ +*Node +1, 0.0, 0.0, 0.0 +*SPHLITE CCLITE, WORKER=YES, REGION=PRESSURE_CONTACT, EXPORT_RADIUS=NO, EXPORT_SOUND_SPEED=YES, ACCEPT_CONTACT_STATE=YES, ACCEPT_BOUNDARY_STATE=NO diff --git a/tests/data/cclite_options_invalid_082.inp b/tests/data/cclite_options_invalid_082.inp new file mode 100644 index 0000000..72f8f75 --- /dev/null +++ b/tests/data/cclite_options_invalid_082.inp @@ -0,0 +1,3 @@ +*Node +1, 0.0, 0.0, 0.0 +*SPHLITE CCLITE, WORKER=MAYBE diff --git a/tests/interface/test_c_api.c b/tests/interface/test_c_api.c index 164d1da..bd5df60 100644 --- a/tests/interface/test_c_api.c +++ b/tests/interface/test_c_api.c @@ -251,7 +251,7 @@ int main(void) ierr = sphlite_get_version(&major, &minor, &patch); if (ierr != 0) return fail("get_version failed"); - if (major != 0 || minor != 8 || patch != 2) return fail("unexpected version"); + if (major != 0 || minor != 8 || patch != 3) return fail("unexpected version"); snprintf(path, sizeof(path), "%s/minimal_particles_011.inp", SPHLITE_TEST_DATA_DIR); ierr = sphlite_read_inp(path); diff --git a/tests/interface/test_cpp_api.cpp b/tests/interface/test_cpp_api.cpp index a79a900..774accf 100644 --- a/tests/interface/test_cpp_api.cpp +++ b/tests/interface/test_cpp_api.cpp @@ -15,7 +15,7 @@ int main() { sphlite::Session session; sphlite::Version version = sphlite::version(); - if (version.major != 0 || version.minor != 8 || version.patch != 2) { + if (version.major != 0 || version.minor != 8 || version.patch != 3) { return 1; } diff --git a/tests/module/test_input_cclite_082.f90 b/tests/module/test_input_cclite_082.f90 new file mode 100644 index 0000000..d1f0bc4 --- /dev/null +++ b/tests/module/test_input_cclite_082.f90 @@ -0,0 +1,62 @@ +program test_input_cclite_082 + use sph_error, only: SPH_SUCCESS + use sph_api, only: sph_initialize, sph_finalize, sph_read_inp + use sph_database, only: cclite_worker_enabled, cclite_region_name, & + cclite_export_radius, cclite_export_sound_speed, & + cclite_accept_contact_state, cclite_accept_boundary_state + implicit none + + integer :: ierr + + call check_valid_cclite_keyword() + call check_invalid_cclite_keyword() + +contains + + subroutine check_valid_cclite_keyword() + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for CCLite input') + call sph_read_inp('tests/data/cclite_options_082.inp', ierr) + call assert_ok(ierr, 'read failed for CCLite input') + if (cclite_worker_enabled /= 1) call fail('CCLite worker flag mismatch') + if (trim(cclite_region_name) /= 'PRESSURE_CONTACT') then + call fail('CCLite region option mismatch') + end if + if (cclite_export_radius /= 0) call fail('CCLite radius flag mismatch') + if (cclite_export_sound_speed /= 1) then + call fail('CCLite sound speed flag mismatch') + end if + if (cclite_accept_contact_state /= 1) then + call fail('CCLite contact state flag mismatch') + end if + if (cclite_accept_boundary_state /= 0) then + call fail('CCLite boundary state flag mismatch') + end if + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for CCLite input') + end subroutine check_valid_cclite_keyword + + subroutine check_invalid_cclite_keyword() + call sph_initialize(ierr) + call assert_ok(ierr, 'initialize failed for invalid CCLite input') + call sph_read_inp('tests/data/cclite_options_invalid_082.inp', ierr) + if (ierr == SPH_SUCCESS) call fail('invalid CCLite option did not fail') + call sph_finalize(ierr) + call assert_ok(ierr, 'finalize failed for invalid CCLite input') + end subroutine check_invalid_cclite_keyword + + 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_input_cclite_082 diff --git a/tests/unit/test_smoke.f90 b/tests/unit/test_smoke.f90 index 7adabea..4f97ad4 100644 --- a/tests/unit/test_smoke.f90 +++ b/tests/unit/test_smoke.f90 @@ -37,7 +37,7 @@ program test_smoke call sph_get_version(major, minor, patch, ierr) call assert_ok(ierr, 'version failed') - if (major /= 0 .or. minor /= 8 .or. patch /= 2) call fail('unexpected version') + if (major /= 0 .or. minor /= 8 .or. patch /= 3) call fail('unexpected version') call sph_db_allocate(2, ierr) call assert_ok(ierr, 'database allocation failed') diff --git a/todo.md b/todo.md index 437752e..fd93dd9 100644 --- a/todo.md +++ b/todo.md @@ -1,6 +1,6 @@ # SPHLite TODO -当前目标:根据 `docs/12_cclite_integration_suggestions.md` 推进 CCLite 集成预研、worker 通信闭环和数据契约补强。 +当前目标:根据 `docs/12_cclite_integration_suggestions.md` 推进真实 CCLite worker 通信闭环、数据契约补强和联调验收。 执行边界: @@ -8,236 +8,274 @@ - 不把 SPHLite 改造成 CCLite 内部库。 - 不新增 FEMLite 直接依赖。 - 不在 SPHLite 内部实现 FEM-SPH 接触搜索或 CCLite 接触算法核心。 -- 优先保持现有 CLI、Fortran API、C ABI、C++ wrapper、Python wrapper 和 release gate 不退化。 +- 不让 worker adapter 侵入 Water、Gas、Explosive、Solid、Shell 等核心物理模块。 +- 不把 mock worker、真实 IPC worker、真实接触/FSI 三类能力混同。 +- 算法核心保持 Fortran 95,包括求解器、粒子/单元语义、材料和物理模块;worker、CLI、IPC 等外围集成层及其测试/工具性 Fortran 代码可使用 Fortran 2018。 +- 保持现有 CLI、Fortran API、C ABI、C++ wrapper、Python wrapper 和 release gate 不退化。 -## 阶段 A:范围收敛和现状复核 +颗粒度约定:每个待办事项应对应一个清晰的小变更、一个测试、一个接口行为或一处文档同步;按阶段顺序推进,非必须不要跳过。 -- [x] 复核 12 号文档中的 SPHLite/CCLite/FEMLite 职责边界。 -- [x] 复核 0.8.0 coupling region 输入解析能力。 -- [x] 复核 0.8.1 facet pressure/traction/resultant 导入能力。 -- [x] 复核现有 contact state 导入和诊断能力。 -- [x] 复核现有 motion boundary direct 模式能力。 -- [x] 复核现有 CSV、VTU、PVD 和 restart 输出能力。 -- [x] 复核现有 C ABI coupling 接口清单。 -- [x] 复核现有 C++ wrapper coupling 接口清单。 -- [x] 复核现有 Python debug coupling 接口清单。 -- [x] 复核现有 CLI coupling 诊断输出字段。 -- [x] 明确 worker/service adapter 不侵入核心物理模块。 -- [x] 明确 CCLite shared memory 和 event 生命周期不由 SPHLite 管理。 -- [x] 明确 worker 通信闭环不等同于真实接触算法完成。 -- [x] 明确下一阶段不交付生产级 FSI 和连续体强耦合。 -- [x] 记录当前 release gate 和 source size 基线。 -- [x] 准备阶段 A 变更小结。 +## 阶段 A:基线和边界复核 -## 阶段 B:CCLite 数据契约 manifest +- [x] 复核 `docs/12_cclite_integration_suggestions.md` 中 SPHLite、CCLite、FEMLite 的职责边界。 +- [x] 复核当前 worker mock 与真实 IPC 未闭合的边界表述。 +- [x] 复核现有 `CouplingInterface` C ABI 清单。 +- [x] 复核现有 C++ wrapper coupling 暴露清单。 +- [x] 复核现有 Python debug coupling 暴露清单。 +- [x] 复核当前 CLI 普通运行、`--check`、`--run` 行为。 +- [x] 复核当前 worker CLI 参数解析行为。 +- [x] 复核当前 worker 状态枚举和命令枚举。 +- [x] 复核当前 worker mock command/data block 契约。 +- [x] 复核当前 coupling diagnostics 和 load balance 字段。 +- [x] 复核当前 CSV、VTU、PVD、restart 输出能力。 +- [x] 复核当前 source size 例外清单。 -- [x] 建立 CCLite 集成数据契约 manifest 文档。 -- [x] 在 manifest 中列出 region info 字段。 -- [x] 在 manifest 中列出 region modes 字段。 -- [x] 在 manifest 中列出现有 particle export 字段。 -- [x] 在 manifest 中列出现有 facet export 字段。 -- [x] 在 manifest 中列出现有 particle force import 字段。 -- [x] 在 manifest 中列出现有 facet load import 字段。 -- [x] 在 manifest 中列出现有 contact state import 字段。 -- [x] 在 manifest 中列出现有 motion boundary import 字段。 -- [x] 在 manifest 中列出现有 load balance 诊断字段。 -- [x] 在 manifest 中列出现有 contact diagnostics 字段。 -- [x] 在 manifest 中标记尚未暴露的 `body_id` 字段。 -- [x] 在 manifest 中标记尚未暴露的 `contact_radius` 字段。 -- [x] 在 manifest 中标记尚未暴露的 `sound_speed` 字段。 -- [x] 在 manifest 中标记尚未暴露的 `source_id` 和 `pair_id` 字段。 -- [x] 在 manifest 中标记尚未暴露的 `valid_flags` 字段。 -- [x] 在 manifest 中标记 boundary/ghost 预留字段。 -- [x] 在 manifest 中说明数组展开顺序。 -- [x] 在 manifest 中说明 external id 与 export index 的使用边界。 -- [x] 将 manifest 接入 docs 索引或 12 号文档引用。 +## 阶段 B:CCLite 能力查询入口 -## 阶段 C:Worker CLI 入口设计 +- [x] 设计 `--cclite-capabilities` CLI 参数语义。 +- [x] 增加 `--cclite-capabilities` 与普通输入文件参数的冲突检查。 +- [x] 增加 `--cclite-capabilities` 与 `--cclite-worker` 的组合规则。 +- [x] 定义 capabilities 输出的 `solver` 字段。 +- [x] 定义 capabilities 输出的 `cclite_worker` 字段。 +- [x] 定义 capabilities 输出的 `ipc_backend` 字段。 +- [x] 定义 capabilities 输出的 `command_block_version` 字段。 +- [x] 定义 capabilities 输出的 `data_layout` 字段。 +- [x] 定义 capabilities 输出的 `supports_real_ipc` 字段。 +- [x] 定义 capabilities 输出的 `supports_sph_to_ccl_particle` 字段。 +- [x] 定义 capabilities 输出的 `supports_ccl_to_sph_force` 字段。 +- [x] 定义 capabilities 输出的 `max_particle_records` 字段。 +- [x] 实现 capabilities 文本输出。 +- [x] 增加 capabilities CLI 正常路径测试。 +- [x] 增加 capabilities CLI 参数冲突测试。 +- [x] 将 capabilities 测试接入 CTest。 -- [x] 设计 `--cclite-worker` CLI 参数语义。 -- [x] 设计 `--solver-id` CLI 参数语义。 -- [x] 设计 `--case` CLI 参数语义。 -- [x] 设计 `--ipc-name` CLI 参数语义。 -- [x] 设计 `--command-block` CLI 参数语义。 -- [x] 设计 `--data-prefix` CLI 参数语义。 -- [x] 设计 `--log` CLI 参数语义。 -- [x] 设计 `--timeout-ms` CLI 参数语义。 -- [x] 设计 `--worker-id` CLI 参数语义。 -- [x] 设计 worker 参数缺失时的错误码和错误消息。 -- [x] 设计 worker 参数冲突时的错误码和错误消息。 -- [x] 确认未启用 worker 时现有 CLI 行为不变。 -- [x] 增加 worker CLI 参数解析单元测试。 -- [x] 增加普通 CLI 回归测试。 -- [x] 增加 worker 参数错误路径测试。 -- [x] 将 worker CLI 测试接入 CTest。 +## 阶段 C:真实 IPC 适配层骨架 -## 阶段 D:Worker 状态机和命令枚举 +- [x] 设计真实 IPC adapter 与 mock adapter 的共同接口。 +- [x] 增加 Windows shared memory 句柄结构。 +- [x] 增加 Windows named event 句柄结构。 +- [x] 增加 command block 打开函数。 +- [x] 增加 data block 打开函数。 +- [x] 增加 command event 打开函数。 +- [x] 增加 done event 打开函数。 +- [x] 增加 command event wait 函数。 +- [x] 增加 done event signal 函数。 +- [x] 增加 shared memory 关闭函数。 +- [x] 增加 named event 关闭函数。 +- [x] 增加 wait 超时错误路径。 +- [x] 增加句柄打开失败错误路径。 +- [x] 增加非 Windows 平台真实 IPC unsupported 路径。 +- [x] 增加真实 IPC adapter 编译开关。 +- [x] 增加 IPC adapter 单元测试。 -- [x] 定义 worker 状态枚举。 -- [x] 定义 worker 命令枚举。 -- [x] 定义 worker ack 序号语义。 -- [x] 定义 worker error code 映射语义。 -- [x] 定义 `INIT` 命令处理流程。 -- [x] 定义 `READ_INPUT` 命令处理流程。 -- [x] 定义 `BUILD_MODEL` 命令处理流程。 -- [x] 定义 `EXPORT_INTERFACE` 命令处理流程。 -- [x] 定义 `IMPORT_LOADS` 命令处理流程。 -- [x] 定义 `ADVANCE` 命令处理流程。 -- [x] 定义 `WRITE_OUTPUT` 命令处理流程。 -- [x] 定义 `STOP` 命令处理流程。 -- [x] 定义未知命令处理流程。 -- [x] 定义命令超时处理流程。 -- [x] 增加 worker 状态机纯逻辑测试。 -- [x] 增加 worker 命令分发表测试。 +## 阶段 D:真实 worker 主循环 -## 阶段 E:IPC 适配层预研 +- [x] 将 worker 启动参数传入真实 IPC adapter。 +- [x] 在 worker 启动后写入 `READY` 状态。 +- [x] 在 worker 启动失败时写入受控错误消息。 +- [x] 实现 worker 等待 command event 的主循环。 +- [x] 实现 command sequence 读取。 +- [x] 实现 command kind 读取。 +- [x] 实现未知 command 的受控错误响应。 +- [x] 实现 `INIT` 命令真实 IPC 路径。 +- [x] 实现 `READ_INPUT` 命令真实 IPC 路径。 +- [x] 实现 `BUILD_MODEL` 命令真实 IPC 路径。 +- [x] 实现 `EXPORT_INTERFACE` 命令真实 IPC 路径。 +- [x] 实现 `IMPORT_LOADS` 命令真实 IPC 路径。 +- [x] 实现 `ADVANCE` 命令真实 IPC 路径。 +- [x] 实现 `WRITE_OUTPUT` 命令真实 IPC 路径。 +- [x] 实现 `STOP` 命令真实 IPC 路径。 +- [x] 每条命令后回写 `ack_seq`。 +- [x] 每条命令后回写 `worker_state`。 +- [x] 每条命令后回写 `error_code`。 +- [x] 每条命令后回写短消息。 +- [x] 每条命令后 signal done event。 -- [x] 设计 IPC 适配层模块边界。 -- [x] 设计 command block 句柄抽象。 -- [x] 设计 data block 句柄抽象。 -- [x] 设计 command event 句柄抽象。 -- [x] 设计 done event 句柄抽象。 -- [x] 设计 READY 状态写入流程。 -- [x] 设计 DONE 状态写入流程。 -- [x] 设计 wait command event 流程。 -- [x] 设计 signal done event 流程。 -- [x] 设计 event 不 reset 的约束检查。 -- [x] 设计 shared memory 打开失败错误路径。 -- [x] 设计 event 打开失败错误路径。 -- [x] 设计 wait 超时错误路径。 -- [x] 设计 Windows 平台条件编译策略。 -- [x] 设计非 Windows 平台的明确错误路径。 -- [x] 增加 IPC adapter mock 测试。 +## 阶段 E:`SPH_TO_CCL_PARTICLE` 数据块 -## 阶段 F:Worker 命令与现有 API 映射 +- [x] 定义 `SPH_TO_CCL_PARTICLE` 数据块版本号。 +- [x] 定义 `SPH_TO_CCL_PARTICLE` 记录容量字段。 +- [x] 定义 `SPH_TO_CCL_PARTICLE` 有效记录数字段。 +- [x] 定义粒子 `external id` 字段。 +- [x] 定义粒子 `internal/export index` 字段。 +- [x] 定义粒子 `phase` 字段。 +- [x] 定义粒子 `status` 字段。 +- [x] 定义粒子 `material id` 字段。 +- [x] 定义粒子 `section id` 字段。 +- [x] 定义粒子 `body id` 占位字段。 +- [x] 定义粒子位置字段。 +- [x] 定义粒子速度字段。 +- [x] 定义粒子质量字段。 +- [x] 定义粒子密度字段。 +- [x] 定义粒子体积字段。 +- [x] 定义粒子光滑长度字段。 +- [x] 定义粒子接触半径字段。 +- [x] 定义粒子压力字段。 +- [x] 定义粒子声速字段。 +- [x] 定义粒子 `valid_flags` 字段。 +- [x] 实现空粒子导出。 +- [x] 实现固定粒子导出。 +- [x] 映射真实 coupling region 粒子导出。 +- [x] 增加粒子导出容量不足错误路径。 -- [x] 将 `READ_INPUT` 映射到 `sphlite_read_inp`。 -- [x] 将 `BUILD_MODEL` 映射到 `sphlite_build_model`。 -- [x] 将 `ADVANCE` 映射到 `sphlite_advance_explicit`。 -- [x] 将 `WRITE_OUTPUT` 映射到 `sphlite_write_output`。 -- [x] 将 `EXPORT_INTERFACE` 映射到 region count 查询。 -- [x] 将 `EXPORT_INTERFACE` 映射到 region info 查询。 -- [x] 将 `EXPORT_INTERFACE` 映射到 particle export。 -- [x] 将 `EXPORT_INTERFACE` 映射到 facet export。 -- [x] 将 `IMPORT_LOADS` 映射到 particle force import。 -- [x] 将 `IMPORT_LOADS` 映射到 facet pressure import。 -- [x] 将 `IMPORT_LOADS` 映射到 facet traction import。 -- [x] 将 `IMPORT_LOADS` 映射到 facet resultant import。 -- [x] 将 `IMPORT_LOADS` 映射到 contact state import。 -- [x] 将 `IMPORT_LOADS` 映射到 motion boundary import。 -- [x] 将 worker error code 映射到 SPHLite last error。 -- [x] 增加 worker API 映射 mock 测试。 +## 阶段 F:导出粒子校验和报告 -## 阶段 G:数据契约 v2 预留 +- [x] 增加导出粒子坐标有限值检查。 +- [x] 增加导出粒子速度有限值检查。 +- [x] 增加导出粒子质量有效性检查。 +- [x] 增加导出粒子密度有效性检查。 +- [x] 增加导出粒子体积有效性检查。 +- [x] 增加导出粒子光滑长度有效性检查。 +- [x] 增加导出粒子接触半径有效性检查。 +- [x] 增加导出粒子压力有限值检查。 +- [x] 增加导出粒子声速有效性检查。 +- [x] 增加导出粒子 phase 有效性检查。 +- [x] 增加导出粒子 status 有效性检查。 +- [x] 增加导出粒子 external id 有效性检查。 +- [x] 增加导出粒子 internal/export index 有效性检查。 +- [x] 将被拒绝导出粒子计入诊断。 +- [x] 将被拒绝导出粒子写入 particle report。 +- [x] 增加导出粒子校验单元测试。 -- [x] 设计 v2 particle export 接口草案。 -- [x] 设计 v2 particle force import 接口草案。 -- [x] 设计 v2 contact state import 接口草案。 -- [x] 设计 v2 boundary state import 接口草案。 -- [x] 设计 `source_id` 存储和诊断语义。 -- [x] 设计 `pair_id` 存储和诊断语义。 -- [x] 设计 `contact_radius` 计算和导出语义。 -- [x] 设计 `sound_speed` 计算和导出语义。 -- [x] 设计 `valid_flags` 位定义。 -- [x] 设计 `body_id` 占位策略。 -- [x] 设计 `moment[3]` 导入和诊断语义。 -- [x] 设计 `interface_pressure` 预留语义。 -- [x] 设计 `interface_velocity` 预留语义。 -- [x] 设计 v2 接口与现有 ABI 共存策略。 -- [x] 设计 v2 C++ wrapper 暴露策略。 -- [x] 设计 v2 Python wrapper 暴露策略。 +## 阶段 G:`CCL_TO_SPH_FORCE` 数据块 -## 阶段 H:外部载荷和接触诊断加固 +- [x] 定义 `CCL_TO_SPH_FORCE` 数据块版本号。 +- [x] 定义 `CCL_TO_SPH_FORCE` 记录容量字段。 +- [x] 定义 `CCL_TO_SPH_FORCE` 有效记录数字段。 +- [x] 定义 force record 的 particle id 字段。 +- [x] 定义 force record 的 internal/export index 字段。 +- [x] 定义 force record 的 force[3] 字段。 +- [x] 定义 force record 的 moment[3] 字段。 +- [x] 定义 force record 的 source id 字段。 +- [x] 定义 force record 的 pair id 字段。 +- [x] 定义 force record 的 load mode 字段。 +- [x] 定义 force record 的 contact state 字段。 +- [x] 定义 force record 的 step id 字段。 +- [x] 定义 force record 的 valid flags 字段。 +- [x] 实现空 force block 导入。 +- [x] 映射粒子力导入到现有 CouplingInterface。 +- [x] 映射接触状态导入到现有 CouplingInterface。 +- [x] 增加 force block 容量越界错误路径。 +- [x] 增加 force block 版本不匹配错误路径。 -- [x] 增加 particle id 未匹配计数设计。 -- [x] 增加 force record 拒绝原因分类设计。 -- [x] 增加非有限 force record 诊断设计。 -- [x] 增加非有限 contact record 诊断设计。 -- [x] 增加 per-region 输入总力诊断设计。 -- [x] 增加 per-region 输入总力矩诊断设计。 -- [x] 增加 per-region 分配后总力诊断设计。 -- [x] 增加 per-region 分配后总力矩诊断设计。 -- [x] 增加 per-region 分配误差诊断设计。 -- [x] 增加 contact state 枚举扩展设计。 -- [x] 增加 tied/release 只读诊断映射设计。 -- [x] 增加 stale epoch 行为复核测试。 -- [x] 增加 repeated import 行为复核测试。 -- [x] 增加 load balance 回归测试。 -- [x] 增加 contact diagnostics 回归测试。 -- [x] 将新增诊断字段写入 manifest。 +## 阶段 H:导入载荷校验和诊断 -## 阶段 I:Boundary/Ghost 与 FSI 预留 +- [x] 增加 force record particle id 匹配检查。 +- [x] 增加 force record internal/export index 匹配检查。 +- [x] 增加 force record force[3] 有限值检查。 +- [x] 增加 force record moment[3] 有限值检查。 +- [x] 增加 force record source id 有效性检查。 +- [x] 增加 force record pair id 诊断记录。 +- [x] 增加 force record load mode 有效性检查。 +- [x] 增加 force record contact state 有效性检查。 +- [x] 增加 force record step id 检查。 +- [x] 增加 force record valid flags 检查。 +- [x] 增加无法匹配 force record 的拒绝计数。 +- [x] 增加非有限 force record 的拒绝计数。 +- [x] 增加过期 step force record 的拒绝计数。 +- [x] 增加重复 force record 的诊断计数。 +- [x] 将导入总力写入 load balance 诊断。 +- [x] 将导入总力矩写入 load balance 诊断。 +- [x] 将拒绝原因写入 force report。 +- [x] 增加导入载荷校验单元测试。 -- [x] 定义 boundary state id 语义。 -- [x] 定义 ghost state id 语义。 -- [x] 定义 boundary position 字段。 -- [x] 定义 boundary velocity 字段。 -- [x] 定义 boundary normal 字段。 -- [x] 定义 boundary pressure 字段。 -- [x] 定义 boundary density 字段。 -- [x] 定义 boundary sound speed 字段。 -- [x] 定义 interface pressure 字段。 -- [x] 定义 interface velocity 字段。 -- [x] 定义 boundary state mode 字段。 -- [x] 定义 boundary valid flags 字段。 -- [x] 设计 boundary state 导入缓存。 -- [x] 设计 boundary state 清零策略。 -- [x] 设计 boundary/ghost smoke 测试。 -- [x] 将 boundary/ghost 能力标记为预留而非生产 FSI。 +## 阶段 I:v2 数据契约和预留接口 -## 阶段 J:Worker 诊断和输出 +- [x] 复核 `cclite_coupling_manifest.md` 的 v2 字段清单。 +- [x] 明确 `body_id` 的默认值和长期语义。 +- [x] 明确 `contact_radius` 与 `h` 的关系。 +- [x] 明确 `sound_speed` 的来源和默认值。 +- [x] 明确 `valid_flags` 位定义。 +- [x] 明确 `source_id` 与 CCLite contact pair 的关系。 +- [x] 明确 `pair_id` 与 contact state 的关系。 +- [x] 明确 `moment[3]` 对 Solid/Shell 的预留语义。 +- [x] 明确 `interface_pressure` 的预留语义。 +- [x] 明确 `interface_velocity` 的预留语义。 +- [x] 设计 `sphlite_coupling_apply_boundary_states` 草案。 +- [x] 设计 boundary/ghost state 缓存容量策略。 +- [x] 设计 boundary/ghost state 清零策略。 +- [x] 增加 boundary/ghost 数据契约 smoke 测试。 +- [x] 标记 boundary/ghost 为预留能力而非生产 FSI。 +- [x] 更新 v2 契约文档。 -- [x] 设计 `sphlite_cclite_worker.log` 内容。 -- [x] 设计 `sphlite_cclite_particle_report.csv` 内容。 -- [x] 设计 `sphlite_cclite_force_report.csv` 内容。 -- [x] 设计 worker 启动参数日志。 -- [x] 设计 command block 名称日志。 -- [x] 设计 data block 名称日志。 -- [x] 设计 command id 日志。 -- [x] 设计 step id 日志。 -- [x] 设计 ack seq 日志。 -- [x] 设计 worker state 日志。 -- [x] 设计导出粒子数量日志。 -- [x] 设计导出 facet 数量日志。 -- [x] 设计接收 force 数量日志。 -- [x] 设计错误码和错误消息日志。 -- [x] 确认 VTU/PVD 输出可用于 worker 结果复核。 -- [x] 增加 worker 诊断文件 smoke 测试。 +## 阶段 J:Worker 诊断输出 -## 阶段 K:CCLite Mock 联调 +- [x] 实现 `sphlite_cclite_worker.log` 文件路径解析。 +- [x] 记录 worker 启动参数。 +- [x] 记录 command block 名称。 +- [x] 记录 data block 名称。 +- [x] 记录 command event 名称。 +- [x] 记录 done event 名称。 +- [x] 记录当前 command id。 +- [x] 记录当前 step id。 +- [x] 记录当前 ack seq。 +- [x] 记录当前 worker state。 +- [x] 记录导出粒子数量。 +- [x] 记录导出 facet 数量。 +- [x] 记录接收 force 数量。 +- [x] 记录接收总力。 +- [x] 记录接收总力矩。 +- [x] 记录非有限粒子状态数量。 +- [x] 记录错误码和错误消息。 +- [x] 实现 `sphlite_cclite_particle_report.csv`。 +- [x] 实现 `sphlite_cclite_force_report.csv`。 +- [x] 增加 worker 诊断输出测试。 -- [x] 设计 CCLite mock command block 数据。 -- [x] 设计 CCLite mock data block 数据。 -- [x] 设计 `INIT` mock 测试。 -- [x] 设计 `READ_INPUT` mock 测试。 -- [x] 设计 `BUILD_MODEL` mock 测试。 -- [x] 设计空 `EXPORT_INTERFACE` mock 测试。 -- [x] 设计固定粒子 `EXPORT_INTERFACE` mock 测试。 -- [x] 设计空 `IMPORT_LOADS` mock 测试。 -- [x] 设计粒子力 `IMPORT_LOADS` mock 测试。 -- [x] 设计 facet load `IMPORT_LOADS` mock 测试。 -- [x] 设计 `ADVANCE` 单步 mock 测试。 -- [x] 设计 `WRITE_OUTPUT` mock 测试。 -- [x] 设计 `STOP` mock 测试。 -- [x] 设计 100 step 空耦合 mock 测试。 -- [x] 设计异常命令 mock 测试。 -- [x] 将 CCLite mock 联调测试接入 CTest。 +## 阶段 K:输入关键词和配置开关 -## 阶段 L:发布和回归验收 +- [x] 复核现有 `*SPHLITE COUPLING REGION` 语法是否满足 CCLite 引用需求。 +- [x] 复核 `EXPORT=PARTICLE/FACET/BOTH` 与 worker 数据块的映射。 +- [x] 复核 `IMPORT=FORCE/FACET_LOAD/MOTION` 与 worker 数据块的映射。 +- [x] 复核 `CONTACT_STATE=OFF/IMPORT` 与 contact state 导入的映射。 +- [x] 设计 `*SPHLITE CCLITE` 关键词草案。 +- [x] 定义 `*SPHLITE CCLITE, WORKER=YES` 语义。 +- [x] 定义 `*SPHLITE CCLITE, REGION=...` 语义。 +- [x] 定义 `EXPORT_RADIUS=YES/NO` 语义。 +- [x] 定义 `EXPORT_SOUND_SPEED=YES/NO` 语义。 +- [x] 定义 `ACCEPT_CONTACT_STATE=YES/NO` 语义。 +- [x] 定义 `ACCEPT_BOUNDARY_STATE=YES/NO` 语义。 +- [x] 明确 `*SPHLITE CCLITE` 不替代 CCLite 配置文件。 +- [x] 增加输入关键词文档。 +- [x] 增加输入关键词解析测试。 -- [x] 更新 README 中 Output 描述为 CSV、VTU、PVD、restart 和诊断输出。 -- [x] 更新 02 号架构文档中的 Output 描述。 -- [x] 更新 05 号接口文档中的 coupling 当前接口清单。 -- [x] 更新 06 号测试文档中的 worker gate 建议。 -- [x] 更新 09 号版本历史中的 CCLite 集成预研记录。 -- [x] 更新 12 号文档中的已完成/待完成状态。 -- [x] 验证 `examples/infinite_underwater_explosion` 双击脚本仍可运行。 -- [x] 验证无限水域爆炸案例仍生成 VTU。 -- [x] 验证无限水域爆炸案例仍生成 PVD。 -- [x] 验证 `tools/publish_to_cclite.bat` dry run。 -- [x] 验证发布版 examples 脚本路径自动调整。 +## 阶段 L:Worker self-test 和 CCLite mock 联调 + +- [x] 设计 SPHLite 侧真实 IPC self-test 启动方式。 +- [x] 准备 self-test 用最小输入文件。 +- [x] 验证 self-test worker 启动。 +- [x] 验证 self-test IPC attach。 +- [x] 验证 self-test `READY` 写入。 +- [x] 验证 self-test 空粒子导出。 +- [x] 验证 self-test 固定粒子导出。 +- [x] 验证 self-test 空 force 导入。 +- [x] 验证 self-test `STOP` 正常退出。 +- [x] 验证 self-test 超时可控退出。 +- [x] 与 CCLite mock FEM 验收 1 step 空耦合。 +- [x] 与 CCLite mock FEM 验收 100 step 空耦合。 +- [x] 与 CCLite mock FEM 验收异常输入退出。 +- [x] 与 CCLite mock FEM 验收超时退出。 +- [x] 记录真实 SPHLite + mock FEM 联调日志。 +- [x] 将可本地执行的 self-test 接入 CTest。 + +## 阶段 M:回归测试和发布准备 + +- [x] 增加 capabilities CLI 回归到 release gate。 +- [x] 增加真实 IPC unsupported 路径回归到 release gate。 +- [x] 增加 worker self-test 回归到 release gate。 +- [x] 增加 particle export 数据块回归到 release gate。 +- [x] 增加 force import 数据块回归到 release gate。 +- [x] 增加粒子校验拒绝路径回归到 release gate。 +- [x] 增加载荷校验拒绝路径回归到 release gate。 +- [x] 增加 worker diagnostics 回归到 release gate。 - [x] 运行 worker/coupling 专项 CTest。 - [x] 运行完整 CTest。 - [x] 运行 source size gate。 - [x] 运行 `git diff --check`。 -- [x] 准备阶段 L 本地提交说明。 +- [x] 运行无限水域爆炸示例脚本。 +- [x] 验证示例 VTU/PVD 输出。 +- [x] 验证 `tools/publish_to_cclite.bat` dry run。 +- [x] 更新 06 号测试与验证计划。 +- [x] 更新 09 号版本历史。 +- [x] 更新 11 号 benchmark matrix。 +- [x] 更新 12 号 CCLite 集成建议状态。 +- [x] 更新 README 当前能力说明。 diff --git a/tools/testing/test_cli.py b/tools/testing/test_cli.py index 607c7f0..dce7b6d 100644 --- a/tools/testing/test_cli.py +++ b/tools/testing/test_cli.py @@ -1,6 +1,7 @@ from __future__ import annotations import argparse +import os import subprocess from pathlib import Path @@ -28,6 +29,15 @@ def read_fields(output: str) -> dict[str, str]: return fields +def read_equals_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]: metrics: dict[str, str] = {} for line in path.read_text(encoding="utf-8").splitlines()[1:]: @@ -52,9 +62,34 @@ def main() -> int: version = run_command([exe, "--version"]) require_field(version.stdout, "version") - if "0.8.2" not in version.stdout: + if "0.8.3" not in version.stdout: raise AssertionError("CLI version mismatch") + capabilities = run_command([exe, "--cclite-capabilities"]) + cap_fields = read_equals_fields(capabilities.stdout) + expected_capabilities = { + "solver": "SPHLite", + "cclite_worker": "yes", + "ipc_backend": "windows_shmem_named_event", + "command_block_version": "1", + "data_layout": "AOR_V1", + "supports_real_ipc": "yes" if os.name == "nt" else "no", + "supports_sph_to_ccl_particle": "yes", + "supports_ccl_to_sph_force": "yes", + "max_particle_records": "4096", + } + for name, expected in expected_capabilities.items(): + if cap_fields.get(name) != expected: + raise AssertionError(f"capabilities field {name} mismatch") + capabilities_conflict = run_command( + [exe, "--cclite-capabilities", "--cclite-worker"], + expect_ok=False, + ) + if "--cclite-capabilities must be used alone" not in ( + capabilities_conflict.stdout + capabilities_conflict.stderr + ): + raise AssertionError("capabilities conflict error mismatch") + inspect = run_command([exe, model]) for field in ( "version", @@ -127,7 +162,7 @@ def main() -> int: ): require_field(inspect.stdout, field) inspect_fields = read_fields(inspect.stdout) - if inspect_fields["version"] != "0.8.2": + if inspect_fields["version"] != "0.8.3": raise AssertionError("inspect version field mismatch") if Path(inspect_fields["input"]) != Path(model): raise AssertionError("inspect input field mismatch") @@ -253,9 +288,12 @@ def main() -> int: ) if ( "worker_state: ERROR" not in worker_unsupported.stdout - or "error_code: 3" not in worker_unsupported.stdout + or ( + "error_code: 3" not in worker_unsupported.stdout + and "error_code: 5" not in worker_unsupported.stdout + ) ): - raise AssertionError("worker unsupported state was not reported") + raise AssertionError("worker IPC error state was not reported") missing_file = run_command([exe, str(Path(output_dir) / "missing.inp")], expect_ok=False) require_field(missing_file.stderr, "error_code") conflict = run_command([exe, model, "--run", "--check"], expect_ok=False) diff --git a/tools/testing/test_python_debug.py b/tools/testing/test_python_debug.py index 86cc2e0..e44d38b 100644 --- a/tools/testing/test_python_debug.py +++ b/tools/testing/test_python_debug.py @@ -78,7 +78,7 @@ def main() -> int: 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, 8, 2): + if solver.version() != (0, 8, 3): raise AssertionError("Python version mismatch") solver.initialize()