rvd-railbench 0.4.1__tar.gz

rvd_railbench-0.4.1/.clang-format

@@ -0,0 +1,5 @@
+BasedOnStyle: Google
+Standard: c++17
+ColumnLimit: 110
+IndentWidth: 2
+SortIncludes: CaseSensitive

rvd_railbench-0.4.1/.clang-tidy

@@ -0,0 +1,3 @@
+Checks: '-*,clang-analyzer-core.*,clang-analyzer-cplusplus.*,clang-analyzer-deadcode.*,bugprone-use-after-move,bugprone-virtual-near-miss'
+WarningsAsErrors: '*'
+HeaderFilterRegex: 'include/rvd/.*'

rvd_railbench-0.4.1/.gitattributes

@@ -0,0 +1,3 @@
+*.onnx binary
+*.bin binary
+*.sh text eol=lf

rvd_railbench-0.4.1/.gitignore

@@ -0,0 +1,19 @@
+build*/
+out/
+.vs/
+.vscode/
+CMakeUserPresets.json
+*.exe
+*.dll
+*.obj
+*.o
+*.pdb
+pfcr_rail_log*.csv
+
+experiments/
+*.tmp
+.venv/
+__pycache__/
+*.egg-info/
+.pytest_cache/
+profiles/

rvd_railbench-0.4.1/CMakeLists.txt

@@ -0,0 +1,155 @@
+cmake_minimum_required(VERSION 3.16)
+project(rvd_railbench VERSION 0.4.1 LANGUAGES CXX)
+
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+include(CTest)
+option(RVD_SIMULATION_ONLY "Disable physical hardware execution" ON)
+option(RVD_WINDOWS_TIMER "Request 1 ms Windows timer resolution" ON)
+set(ONNXRUNTIME_ROOT "" CACHE PATH "ONNX Runtime package root (include/, lib/)")
+set(_ort_default OFF)
+if(ONNXRUNTIME_ROOT)
+  set(_ort_default ON)
+endif()
+option(RVD_ENABLE_ONNX "Enable optional ONNX Runtime backend" ${_ort_default})
+if(NOT RVD_SIMULATION_ONLY)
+  message(FATAL_ERROR "Hardware drivers and interlocks are not implemented; use RVD_SIMULATION_ONLY=ON")
+endif()
+
+add_library(rvd_build_options INTERFACE)
+target_compile_features(rvd_build_options INTERFACE cxx_std_17)
+set(CMAKE_CXX_EXTENSIONS OFF)
+# Keep the original arithmetic order, including in downstream controller adapters.
+if(MSVC)
+  target_compile_options(rvd_build_options INTERFACE /fp:precise /W4 /utf-8)
+else()
+  target_compile_options(rvd_build_options INTERFACE -fno-fast-math -ffp-contract=off -Wall -Wextra -Wpedantic)
+endif()
+
+add_library(pfcr_core src/pfcr_controller.cpp src/policy_builtin.cpp src/policy_onnx.cpp)
+add_library(rvd::pfcr ALIAS pfcr_core)
+target_include_directories(pfcr_core PUBLIC include)
+target_link_libraries(pfcr_core PUBLIC rvd_build_options)
+if(RVD_ENABLE_ONNX)
+  find_path(ONNXRUNTIME_INCLUDE onnxruntime_cxx_api.h PATHS "${ONNXRUNTIME_ROOT}/include" NO_DEFAULT_PATH)
+  find_library(ONNXRUNTIME_LIB onnxruntime PATHS "${ONNXRUNTIME_ROOT}/lib" NO_DEFAULT_PATH)
+  if(NOT ONNXRUNTIME_INCLUDE OR NOT ONNXRUNTIME_LIB)
+    message(FATAL_ERROR "RVD_ENABLE_ONNX requires ONNXRUNTIME_ROOT with headers and library")
+  endif()
+  add_library(rvd_onnx UNKNOWN IMPORTED)
+  set_target_properties(rvd_onnx PROPERTIES IMPORTED_LOCATION "${ONNXRUNTIME_LIB}"
+    INTERFACE_INCLUDE_DIRECTORIES "${ONNXRUNTIME_INCLUDE}")
+  target_compile_definitions(pfcr_core PUBLIC PFCR_WITH_ONNXRUNTIME)
+  target_link_libraries(pfcr_core PUBLIC rvd_onnx)
+endif()
+
+add_library(rvd_runtime
+  src/core/artifact.cpp
+  src/control/pfcr_adapter.cpp
+  src/simulation/rail_simulator.cpp
+  src/runtime/runtime.cpp
+  src/runtime/experiment.cpp
+  src/runtime/replay.cpp
+  src/runtime/safety.cpp
+  src/runtime/config.cpp
+  src/runtime/options.cpp
+  src/runtime/telemetry.cpp
+)
+add_library(rvd::runtime ALIAS rvd_runtime)
+find_package(Git QUIET)
+set(RVD_GIT_COMMIT "unknown")
+set(RVD_GIT_DIRTY "unknown")
+if(GIT_FOUND)
+  execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse HEAD WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    OUTPUT_VARIABLE _git_commit OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET RESULT_VARIABLE _git_status)
+  if(_git_status EQUAL 0)
+    set(RVD_GIT_COMMIT "${_git_commit}")
+  endif()
+  execute_process(COMMAND ${GIT_EXECUTABLE} status --porcelain WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+    OUTPUT_VARIABLE _git_changes OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
+  if(NOT _git_status EQUAL 0)
+    set(RVD_GIT_DIRTY "unknown")
+  elseif(_git_changes)
+    set(RVD_GIT_DIRTY "true")
+  else()
+    set(RVD_GIT_DIRTY "false")
+  endif()
+endif()
+target_compile_definitions(rvd_runtime PRIVATE RVD_GIT_COMMIT="${RVD_GIT_COMMIT}" RVD_GIT_DIRTY="${RVD_GIT_DIRTY}")
+add_executable(rail_replay apps/rail_replay.cpp)
+target_link_libraries(rail_replay PRIVATE rvd_runtime)
+target_link_libraries(rvd_runtime PUBLIC pfcr_core)
+add_executable(rail_main apps/rail_main.cpp)
+target_link_libraries(rail_main PRIVATE rvd_runtime)
+if(WIN32 AND RVD_WINDOWS_TIMER)
+  target_compile_definitions(rail_main PRIVATE RVD_WINDOWS_TIMER)
+  target_link_libraries(rail_main PRIVATE winmm)
+endif()
+
+# Python wheel (scikit-build-core): simulator, policy artifacts and configurations under rvdlab/runtime.
+if(SKBUILD)
+  if(MINGW)
+    target_link_options(rail_main PRIVATE -static)
+    target_link_options(rail_replay PRIVATE -static)
+  endif()
+  install(TARGETS rail_main rail_replay RUNTIME DESTINATION bin)
+  install(DIRECTORY configs/ DESTINATION configs)
+  install(DIRECTORY policies/ DESTINATION policies)
+  if(RVD_SIMULATION_ONLY)
+    set(RVD_RUNTIME_SIMULATION_ONLY true)
+  else()
+    set(RVD_RUNTIME_SIMULATION_ONLY false)
+  endif()
+  set(RVD_RUNTIME_BUILD_TYPE "${CMAKE_BUILD_TYPE}")
+  if(NOT RVD_RUNTIME_BUILD_TYPE)
+    set(RVD_RUNTIME_BUILD_TYPE Release)  # multi-config generators: wheels are built with --config Release
+  endif()
+  configure_file(tui/runtime.json.in runtime.json @ONLY)
+  install(FILES "${CMAKE_CURRENT_BINARY_DIR}/runtime.json" DESTINATION .)
+endif()
+
+if(BUILD_TESTING)
+  add_executable(golden_test tests/golden_test.cpp)
+  target_link_libraries(golden_test PRIVATE pfcr_core)
+  add_test(NAME golden_builtin COMMAND golden_test ${CMAKE_CURRENT_SOURCE_DIR})
+  set_tests_properties(golden_builtin PROPERTIES LABELS "regression" TIMEOUT 120)
+  if(RVD_ENABLE_ONNX)
+    add_test(NAME golden_onnx COMMAND golden_test ${CMAKE_CURRENT_SOURCE_DIR} --onnx)
+    set_tests_properties(golden_onnx PROPERTIES LABELS "regression;onnx" TIMEOUT 120)
+  endif()
+endif()
+
+if(BUILD_TESTING)
+  function(rvd_test name category source)
+    add_executable(${name} ${source})
+    target_link_libraries(${name} PRIVATE rvd_runtime)
+    target_include_directories(${name} PRIVATE tests)
+    add_test(NAME ${name} COMMAND ${name} ${CMAKE_CURRENT_SOURCE_DIR})
+    set_tests_properties(${name} PROPERTIES LABELS "${category}" TIMEOUT 120)
+  endfunction()
+  find_package(Python3 3.9 COMPONENTS Interpreter REQUIRED)
+  add_test(NAME protected_inputs COMMAND ${Python3_EXECUTABLE}
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/regression/protected_inputs_test.py ${CMAKE_CURRENT_SOURCE_DIR})
+  set_tests_properties(protected_inputs PROPERTIES LABELS "regression" TIMEOUT 30)
+  add_test(NAME runtime_integration COMMAND ${Python3_EXECUTABLE}
+    ${CMAKE_CURRENT_SOURCE_DIR}/tests/integration/runtime_test.py
+    $<TARGET_FILE:rail_main> $<TARGET_FILE:rail_replay> ${CMAKE_CURRENT_SOURCE_DIR} ${RVD_ENABLE_ONNX})
+  set_tests_properties(runtime_integration PROPERTIES LABELS "integration;faults;regression" TIMEOUT 120)
+  rvd_test(safety_time_test faults tests/faults/safety_time_test.cpp)
+  rvd_test(simulation_test "unit;faults" tests/faults/simulation_test.cpp)
+  rvd_test(controller_artifact_test unit tests/unit/controller_artifact_test.cpp)
+  rvd_test(frames_config_test unit tests/unit/frames_config_test.cpp)
+endif()
+
+if(RVD_ENABLE_ONNX AND WIN32)
+  file(GLOB ORT_DLLS "${ONNXRUNTIME_ROOT}/lib/*.dll")
+  foreach(t rail_main rail_replay golden_test safety_time_test simulation_test controller_artifact_test frames_config_test)
+    if(TARGET ${t})
+      foreach(dll ${ORT_DLLS})
+        add_custom_command(TARGET ${t} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different
+          "${dll}" $<TARGET_FILE_DIR:${t}>)
+      endforeach()
+    endif()
+  endforeach()
+endif()

rvd_railbench-0.4.1/CMakePresets.json

@@ -0,0 +1,69 @@
+{
+  "version": 3,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 21,
+    "patch": 0
+  },
+  "configurePresets": [
+    {
+      "name": "dev",
+      "displayName": "C++17 simulation development",
+      "generator": "Ninja",
+      "binaryDir": "${sourceDir}/build/dev",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "BUILD_TESTING": "ON",
+        "RVD_SIMULATION_ONLY": "ON",
+        "RVD_ENABLE_ONNX": "OFF"
+      }
+    },
+    {
+      "name": "release",
+      "inherits": "dev",
+      "binaryDir": "${sourceDir}/build/release",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release"
+      }
+    },
+    {
+      "name": "minimal",
+      "inherits": "release",
+      "binaryDir": "${sourceDir}/build/minimal",
+      "cacheVariables": {
+        "BUILD_TESTING": "OFF",
+        "RVD_WINDOWS_TIMER": "OFF"
+      }
+    }
+  ],
+  "buildPresets": [
+    {
+      "name": "dev",
+      "configurePreset": "dev"
+    },
+    {
+      "name": "release",
+      "configurePreset": "release"
+    },
+    {
+      "name": "minimal",
+      "configurePreset": "minimal"
+    }
+  ],
+  "testPresets": [
+    {
+      "name": "dev",
+      "configurePreset": "dev",
+      "output": {
+        "outputOnFailure": true
+      }
+    },
+    {
+      "name": "release",
+      "configurePreset": "release",
+      "output": {
+        "outputOnFailure": true
+      }
+    }
+  ]
+}

rvd_railbench-0.4.1/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

rvd_railbench-0.4.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: rvd-railbench
+Version: 0.4.1
+Summary: Rail-based ground testbed for spacecraft rendezvous and docking, with the RVDLAB terminal interface
+License-Expression: Apache-2.0
+License-File: LICENSE
+Project-URL: Repository, https://github.com/Strtus/rvd-railbench
+Requires-Python: >=3.10
+Requires-Dist: textual>=8.2
+

rvd_railbench-0.4.1/apps/rail_main.cpp

@@ -0,0 +1,33 @@
+#include <cstdio>
+#include <stdexcept>
+
+#include "rvd/runtime.hpp"
+#if defined(_WIN32) && defined(RVD_WINDOWS_TIMER)
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+// clang-format off: Windows types must precede the multimedia declarations.
+#include <windows.h>
+#include <timeapi.h>
+// clang-format on
+struct TimerResolution {
+  TimerResolution() { timeBeginPeriod(1); }
+  ~TimerResolution() { timeEndPeriod(1); }
+};
+#endif
+int main(int argc, char** argv) {
+#if defined(_WIN32) && defined(RVD_WINDOWS_TIMER)
+  TimerResolution timer;
+#endif
+  try {
+    const auto opt = rvd::parse_options(argc, argv);
+    return rvd::run(opt);
+  } catch (const std::exception& e) {
+    if (std::string(e.what()) == "help") return 0;
+    std::fprintf(stderr, "fatal: %s\n", e.what());
+    return 2;
+  }
+}

rvd_railbench-0.4.1/apps/rail_replay.cpp

@@ -0,0 +1,17 @@
+#include <cstdio>
+
+#include "rvd/experiment.hpp"
+int main(int argc, char** argv) {
+  if (argc < 2 || argc > 3) {
+    std::fprintf(stderr, "usage: rail_replay EXPERIMENT_DIR [MODEL_DIR]\n");
+    return 2;
+  }
+  try {
+    const auto r = rvd::replay(argv[1], argc == 3 ? argv[2] : rvd::find_model_dir());
+    std::printf("replayed %d controller inputs, maximum output error %.17g\n", r.steps, r.max_error);
+    return 0;
+  } catch (const std::exception& e) {
+    std::fprintf(stderr, "replay failed: %s\n", e.what());
+    return 2;
+  }
+}

rvd_railbench-0.4.1/configs/pfcr_dqp.ini

@@ -0,0 +1,6 @@
+[controller]
+type = pfcr-dqp
+model_id = E_PFCR-DQP_s41_step5120000
+period_s = 1
+backend = builtin
+ood_warn_z = 6.5

rvd_railbench-0.4.1/configs/rail.ini

@@ -0,0 +1,18 @@
+# SI units. These are simulation operating limits, not verified hardware ratings.
+[rail]
+minimum_m = 0,-0.5,-0.5
+maximum_m = 20,0.5,0.5
+velocity_m_s = 0.5,0.2,0.2
+acceleration_m_s2 = 0.5,0.2,0.2
+measurement_age_s = 0.2
+measurement_late_s = 0.3
+clock_skew_s = 0.005
+sample_jitter_s = 0.2
+communication_timeout_s = 0.3
+tracking_error_m = 0.05
+compensate_latency = false
+[mapping]
+axis = 0,1,2
+sign = 1,1,1
+scale = 1,0.1,0.1
+target_m = 0,0,0

rvd_railbench-0.4.1/configs/simulation.ini

@@ -0,0 +1,13 @@
+[simulation]
+mode = ideal
+seed = 12345
+noise_m = 0.0005
+latency_s = 0.01
+bias_m = 0,0,0
+freeze_at = -1
+fail_read_at = -1
+fail_send_at = -1
+start_hill_m = 18,0.3,-0.2
+fast = false
+open_loop = false
+max_steps = -1

rvd_railbench-0.4.1/include/pfcr/pfcr_controller.hpp

@@ -0,0 +1,84 @@
+// Observation -> policy -> CBF-QP + backup guard -> thruster model -> CWH step (dt = 1 s).
+// Hill frame: x radial (docking port on +x), y along-track, z cross-track. SI units.
+#pragma once
+
+#include <array>
+#include <memory>
+#include <string>
+
+#include "pfcr/pfcr_params.hpp"
+
+namespace pfcr {
+
+using Vec3 = std::array<double, 3>;
+using Vec6 = std::array<double, 6>;
+using Obs = std::array<float, params::kObsDim>;
+using Action = std::array<float, 3>;
+
+class Policy {
+ public:
+  virtual ~Policy() = default;
+  // raw observation -> deterministic action in [-1, 1]^3
+  virtual Action act(const Obs& obs) = 0;
+  virtual std::string name() const = 0;
+};
+
+std::unique_ptr<Policy> make_builtin_policy(const std::string& weights_bin_path);
+#ifdef PFCR_WITH_ONNXRUNTIME
+std::unique_ptr<Policy> make_onnx_policy(const std::string& onnx_path);
+#endif
+
+struct ObsStats {
+  std::array<double, params::kObsDim> mean{};
+  std::array<double, params::kObsDim> std{};
+  bool load(const std::string& weights_bin_path);
+  double max_abs_z(const Obs& obs, int* index = nullptr) const;
+};
+
+struct ActuatorEmulation {
+  double tau = 0.0;            // first-order lag [s]
+  Vec3 scale{1.0, 1.0, 1.0};   // per-axis thrust scale
+  double deadzone = 0.0;       // [N]
+};
+
+enum class Status { Run, Docked, Abort };
+enum class VelocitySource { Model, Measured, FiniteDifference };
+const char* status_name(Status s);
+
+struct StepResult {
+  Status status = Status::Run;
+  std::string reason;
+  int k = 0;
+  double t = 0.0;                    // [s]
+  Vec6 state{};                      // state used this step
+  Obs obs{};
+  Action action{};
+  Vec3 u_des{}, u_act{}, u_real{};   // [N]
+  Vec6 next_state{};                 // reference for t + dt
+  bool backup_active = false;
+  bool intervened = false;
+  double dist = 0.0, speed = 0.0, min_margin = 0.0;
+};
+
+class Controller {
+ public:
+  Controller(std::unique_ptr<Policy> policy, ActuatorEmulation actuator = {},
+             VelocitySource velocity_source = VelocitySource::Model, double tracking_tol_m = 0.10);
+  ~Controller();
+  Controller(const Controller&) = delete;
+  Controller& operator=(const Controller&) = delete;
+
+  void reset(const Vec6& state0);
+  // once per control period; vel_measured only for VelocitySource::Measured
+  StepResult step(const Vec3& pos_measured, const Vec3* vel_measured = nullptr);
+
+  bool running() const;
+  const Vec6& predicted_state() const;
+  const Policy& policy() const;
+
+ private:
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
+}  // namespace pfcr