diff --git a/docs/ground/ride_comfort_transmissibility.md b/docs/ground/ride_comfort_transmissibility.md
new file mode 100644
index 0000000000..02fddfd12c
--- /dev/null
+++ b/docs/ground/ride_comfort_transmissibility.md
@@ -0,0 +1,197 @@
+# 乘坐舒适性传递率
+
+路面不是平的。同一辆车,40 km/h 过某段路很难受,60 km/h 反而平稳 —— 这不是错觉,
+是**悬架对不同频率的输入放大倍数不同**。把这件事算清楚,就是本模块要讲的传递率。
+
+这个模块用纯标准库实现一个单自由度悬架模型,给出共振在哪个频率、放大多少倍、
+按 ISO 2631-1 属于哪个舒适度等级,并用四条断言把「算得对不对」钉住。
+不需要 CARLA、不需要显示器、不需要 numpy,Ubuntu 18.04 + ROS Melodic 直接可跑。
+
+## 一、为什么需要这个包
+
+仓库里 `src/ground/` 下的地面载具模块,纵向有 `braking_distance_check`、横向有
+`rollover_margin` 与 `lateral_stability_margin`,**垂直方向是空白**:
+
+| 方向 | 已有模块 | 管什么 |
+|---|---|---|
+| 纵向 | `braking_distance_check` | 反应距离 + 制动距离 |
+| 横向(侧翻) | `rollover_margin` | 载荷转移与临界车速 |
+| 横向(转向) | `lateral_stability_margin` | 不足转向梯度与特征车速 |
+| 执行器 | `steering_actuator_lag` | 转向机构的一阶滞后 |
+| **垂直** | **本模块** | **悬架传递率、共振、舒适度等级** |
+
+一条真实的工程链条是:悬架把路面震动放大到人体 → 人难受 → 驾驶员反应变慢 →
+制动距离变长。前面三个模块都假设「驾驶员状态正常」,本模块补上这个前提被破坏时的量化依据。
+
+## 二、模型
+
+单自由度基础激励(只看垂直方向,忽略俯仰与侧倾耦合):
+
+```
+r = f / f_n 频率比(激励频率 / 固有频率)
+T(r) = sqrt((1 + (2ζr)²) / ((1 − r²)² + (2ζr)²)) 位移传递率
+a_w = T(r) · a_in 加权加速度 RMS
+```
+
+三个解析结论:
+
+```
+峰值位置 r_p = sqrt(1 − 2ζ²)
+峰值大小 T_p = sqrt((1 + 4ζ²(1−2ζ²)) / (4ζ²(1−ζ²)))
+低频/高频 T(0) = 1;T(∞) = 0
+```
+
+**峰值不在 r = 1**。r = 1 处 `T = sqrt(1+(2ζ)²)/(2ζ)`,ζ = 0.25 时是 2.236;
+真正的极值在 r_p = 0.935,峰值 2.280,高出约 2%。阻尼越大偏得越多。
+
+`damping` 被限制在 `(0, 1/√2)`:超过 0.7071 后 `sqrt(1−2ζ²)` 无实数意义,闭式峰位失效,
+程序直接抛 `RideError`,而不是给一个错的数。现实里的悬架阻尼比也不会到 0.8。
+
+舒适度等级(ISO 2631-1,`a_w` 单位 m/s² RMS):
+
+| a_w 区间 | 等级 |
+|---|---|
+| < 0.315 | 舒适 |
+| 0.315 ~ 0.63 | 略有不适 |
+| 0.63 ~ 1.0 | 不适 |
+| 1.0 ~ 1.6 | 很不适 |
+| 1.6 ~ 2.5 | 极不适 |
+| > 2.5 | 无法忍受 |
+
+## 三、四条断言
+
+| 断言 | 判据 | 默认实测 | 结果 |
+|---|---|---|---|
+| 共振位置 | 扫描峰位与 `sqrt(1−2ζ²)` 的偏差 ≤ 0.02 | 偏差 0.0132 | PASS |
+| 峰值倍率 | 扫描峰值与闭式峰值的相对偏差 ≤ 5% | 偏差 0.0012(0.12%) | PASS |
+| 高频衰减 | `T(r=10) ≤ 0.1` | 0.051440 | PASS |
+| 输入线性 | 输入加倍后 `a_w` 精确加倍 | 相对偏差 0.0000 | PASS |
+
+四条互相独立:位置管「峰在哪」、倍率管「峰多高」、衰减管「隔振行不行」、
+线性管「叠加原理成不成立」。任何一条失败都能定位到具体环节。
+
+## 四、默认数字
+
+参数:`fn_hz = 1.2`、`damping = 0.25`、`input_accel = 0.5`、`freq_hz = 6.0`
+
+| 项 | 值 |
+|---|---|
+| 理论峰位 / 峰值 | **0.935414 / 2.280351** |
+| 扫描峰位 / 峰值 | 0.948625 / 2.283149 |
+| r = 1 处传递率 | 2.236068 |
+| r = 10 处传递率 | 0.051440 |
+| 6 Hz 处加权加速度 | 0.055794 m/s² → 等级「舒适」 |
+
+扫描表(10 个频率比,报告里原样打印):
+
+| r | f Hz | T | a_w m/s² |
+|---|---|---|---|
+| 0.25 | 0.300 | 1.066 | 0.533 |
+| 0.50 | 0.600 | 1.304 | 0.652 |
+| 0.75 | 0.900 | 1.853 | 0.927 |
+| 1.00 | 1.200 | 2.236 | 1.118 |
+| 1.25 | 1.500 | 1.402 | 0.701 |
+| 1.50 | 1.800 | 0.857 | 0.429 |
+| 2.00 | 2.400 | 0.447 | 0.224 |
+| 3.00 | 3.600 | 0.221 | 0.111 |
+| 5.00 | 6.000 | 0.112 | 0.056 |
+| 10.00 | 12.000 | 0.051 | 0.026 |
+
+`r ≤ 1.5` 时 T > 1(放大),`r ≥ 2` 后迅速掉下来(隔振)。这就是过减速带要慢、
+跑高速反而稳的物理原因。
+
+## 五、参数
+
+| 参数 | 默认 | 说明 |
+|---|---|---|
+| `/suspension/fn_hz` | 1.2 | 悬架固有频率 Hz |
+| `/suspension/damping` | 0.25 | 阻尼比,必须在 (0, 0.7071) 开区间 |
+| `/road/input_accel` | 0.5 | 路面输入加速度 RMS m/s² |
+| `/road/freq_hz` | 6.0 | 关心的激励频率 Hz |
+| `/check/pos_tolerance` | 0.02 | 峰位容差(频率比) |
+| `/check/peak_tolerance` | 0.05 | 峰值相对容差 |
+| `/check/high_freq_limit` | 0.1 | r=10 时传递率上限 |
+| `/check/linear_tolerance` | 0.02 | 输入加倍的线性容差 |
+| `/scan/low` `/scan/high` `/scan/steps` | 0.05 / 4.0 / 400 | 扫描区间与步数 |
+| `/rate/publish_hz` | 1.0 | 保活重发频率 Hz |
+
+## 六、话题
+
+| 话题 | 类型 | 内容 |
+|---|---|---|
+| `/ride/report` | `std_msgs/String` | 整份报告(含断言与结论) |
+| `/ride/curve` | `std_msgs/Float64MultiArray` | 每个频率比三元组 `[r, T, a_w]`,共 30 个数 |
+| `/ride/peak` | `std_msgs/Float64MultiArray` | `[理论峰位, 理论峰值, 扫描峰位, 扫描峰值, 激励处 a_w]` |
+
+三条都 `latch=True`。
+
+## 七、运行
+
+```bash
+mkdir -p ~/catkin_ws19/src/ground ~/catkin_ws19/tests ~/catkin_ws19/docs/ground
+# 把包放进来,改 shebang,catkin_make,source,roslaunch
+roslaunch ride_comfort_transmissibility main.launch
+```
+
+默认输出 `结论:PASSED`。两个反例:
+
+```bash
+# ① 容差收到 0.001:扫描精度不够,只翻「共振位置」
+roslaunch ride_comfort_transmissibility main.launch pos_tolerance:=0.001
+
+# ② 阻尼 0.02(坏减振器)+ 激励挪到 1.2 Hz:峰值 25 倍,等级「无法忍受」
+roslaunch ride_comfort_transmissibility main.launch damping:=0.02 freq_hz:=1.2
+```
+
+反例②值得多看一眼:四条断言**全部通过**(物理上它自洽),但舒适等级从「舒适」
+变成「无法忍受」。**断言管的是「算得对不对」,等级管的是「人坐着难受不难受」** ——
+两者不能互相替代,这也是我特意把等级做成独立输出的原因。
+
+## 八、离线测试
+
+```bash
+python3 tests/test_ride_comfort_transmissibility_local.py
+```
+
+**通过 112 项,失败 0 项**,覆盖:
+
+| 组 | 内容 |
+|---|---|
+| A | 传递率基本形(T(0)=1、T(1)、单调段) |
+| B | 闭式峰位与峰值 |
+| C | 舒适度等级分档 |
+| D | 四条断言的正反例 |
+| E | 扫描表数值与单调性 |
+| F | 字符图排版 |
+| G | 参数读取与非法值拒绝 |
+| H | 报告排版(表头、行数、结论) |
+| I | 闭式恒等式(r_p 处取 T 就是 T_p) |
+| J | 三个脚本的工程约定(shebang、coding、保活) |
+| K | 编码声明回归(防 `Non-ASCII character` 报错) |
+
+## 九、与已有模块的分工
+
+前面第一节的表已经列了纵向/横向/执行器/垂直四块。补一句边界:
+`steering_actuator_lag` 也是「频率响应」,但它是**转向机构**的一阶惯性;
+本模块是**悬架**的二阶共振。两者都有「频率越高越跟不上」,但物理对象、微分方程阶数、
+关心的频段完全不同(转向 2~10 Hz,车身 1~2 Hz)。
+
+## 十、常见问题
+
+**1. 为什么峰值不在 r = 1?**
+因为 r = 1 只是「分母实部为 0」的位置,不是传递率对 r 的极值点。
+`T(1) = sqrt(1+(2ζ)²)/(2ζ)`,极值点在 `r = sqrt(1−2ζ²)`,ζ = 0.25 时差 1.3%。
+判据里写「峰位」而不是直接拿 r = 1 当峰,就是为了不让这个偏差蒙混过去。
+
+**2. 为什么 `damping:=0.8` 直接报错?**
+超过 `1/√2 ≈ 0.7071` 后曲线没有经典共振峰,`sqrt(1−2ζ²)` 是虚数。
+与其返回一个错的峰位,不如判参数非法。测试 G15 就是查这个事情。
+
+**3. 高通/低通行为怎么读?**
+`r → 0` 时 `T → 1`(车身跟着路面一起动,等于没悬架);`r → ∞` 时 `T → 0`
+(高频震动被滤掉)。所以舒适性设计的目标是:把共振峰挪到人最不敏感的低频、
+同时把峰压下去 —— 后者靠加阻尼,前者靠改固有频率(也就是改悬架刚度与簧上质量)。
+
+## 十一、大模型使用声明
+
+本模块的代码编写、测试编写与文档整理使用了 AI 编程助手辅助,提交内容由本人负责。
diff --git a/docs/index.md b/docs/index.md
index af6c5528a3..4e2af9e62b 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -245,6 +245,7 @@ ROS 2 服务与参数基础实验(无人机模式切换与在线调参):[c
* [轮胎滑移率-附着曲线](./ground/tire_slip_curve.md) —— 用简化刷子轮胎模型输出滑移率与附着系数关系,标出峰值附着与 ABS 目标滑移带
* [横向载荷转移与侧翻裕度](./ground/rollover_margin.md) —— 用 SSF、临界侧向加速度和内外侧轮垂向力算「这车会不会翻」,纯代数、不依赖 CARLA
* [工况能耗与续航核算](./ground/drive_cycle_energy.md) —— 把一段行驶工况拆成滚阻、风阻、制动与动能项,算清楚电花在哪、还能跑多远
+* [乘坐舒适性传递率](./ground/ride_comfort_transmissibility.md) —— 用二自由度悬架加 ISO 2631 频率加权算路面振动传到人身上剩多少,解释「40 难受、60 反而稳」
## 5. 空域载具
diff --git a/mkdocs.yml b/mkdocs.yml
index c06875d5bf..5dd9a7cbb4 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -239,6 +239,7 @@ nav:
- 轮胎滑移率-附着曲线: './ground/tire_slip_curve.md'
- 横向载荷转移与侧翻裕度: './ground/rollover_margin.md'
- 工况能耗与续航核算: './ground/drive_cycle_energy.md'
+ - 乘坐舒适性传递率: './ground/ride_comfort_transmissibility.md'
- 空域载具:
- MuJoCo 城市屋顶光伏覆盖率测量: './air/mujoco_uav_rooftop_pv_coverage_survey.md'
- MuJoCo 屋顶光伏覆盖率测量第二天: './air/mujoco_uav_rooftop_pv_coverage_survey_day2.md'
diff --git a/src/ground/ride_comfort_transmissibility/CMakeLists.txt b/src/ground/ride_comfort_transmissibility/CMakeLists.txt
new file mode 100644
index 0000000000..4f2d66baab
--- /dev/null
+++ b/src/ground/ride_comfort_transmissibility/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.0.2)
+project(ride_comfort_transmissibility)
+
+find_package(catkin REQUIRED)
+
+catkin_package()
+
+catkin_install_python(PROGRAMS
+ scripts/main.py
+ scripts/ride_core.py
+ scripts/ride_node.py
+ DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
+)
+
+install(DIRECTORY launch config
+ DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION}
+ USE_SOURCE_PERMISSIONS
+)
diff --git a/src/ground/ride_comfort_transmissibility/README.md b/src/ground/ride_comfort_transmissibility/README.md
new file mode 100644
index 0000000000..745e1475aa
--- /dev/null
+++ b/src/ground/ride_comfort_transmissibility/README.md
@@ -0,0 +1,159 @@
+# ride_comfort_transmissibility:乘坐舒适性传递率
+
+路面是一段段不同频率的起伏。车过某段搓板路时抖得厉害、换个车速又平稳了,
+原因是悬架对不同频率的输入放大倍数不一样 —— 这就是**传递率**。
+这个模块把它算清楚:共振在哪个频率、放大多少倍、按 ISO 2631-1 属于哪个舒适度等级。
+
+不依赖 CARLA、不需要显示器,纯 Python 标准库,Python 2.7 / 3.x 都能跑。
+
+## 模型
+
+单自由度基础激励(只看垂直方向):
+
+```
+r = f / f_n 频率比
+T(r) = sqrt((1 + (2ζr)²) / ((1 − r²)² + (2ζr)²)) 位移传递率
+
+峰值位置 r_p = sqrt(1 − 2ζ²) (ζ ≥ 1/√2 时没有经典共振峰)
+峰值大小 T_p = sqrt((1 + 4ζ²(1−2ζ²)) / (4ζ²(1−ζ²)))
+高频衰减 T(r) → 0,r = 10 时约 0.05
+加权加速度 a_w = T(r) · a_in
+```
+
+ISO 2631-1 的舒适度等级(`a_w` 单位 m/s²,RMS):
+
+| a_w | 等级 |
+|---|---|
+| < 0.315 | 舒适 |
+| 0.315 ~ 0.63 | 略有不适 |
+| 0.63 ~ 1.0 | 不适 |
+| 1.0 ~ 1.6 | 很不适 |
+| 1.6 ~ 2.5 | 极不适 |
+| > 2.5 | 无法忍受 |
+
+`damping` 被限制在 `(0, 1/√2)`:超过 0.7071 之后 `sqrt(1−2ζ²)` 没有实数意义,
+闭式峰位失效,程序直接报 `RideError`,而不是给一个错的数。
+
+## 默认数字(`config/ride_comfort_transmissibility.yaml`)
+
+| 项 | 值 |
+|---|---|
+| 悬架固有频率 / 阻尼比 | 1.2 Hz / 0.25 |
+| 路面输入 / 激励频率 | 0.5 m/s² / 6.0 Hz |
+| 理论峰位 / 峰值 | **0.935414 / 2.280351** |
+| 扫描峰位 / 峰值 | 0.948625 / 2.283149(与闭式差 0.12%) |
+| r = 1 处传递率 | 2.236068 |
+| r = 10 处传递率 | 0.051440 |
+| 6 Hz 处加权加速度 | 0.055794 m/s² → 等级「舒适」 |
+
+扫描表(10 个频率比):
+
+| r | f Hz | T | a_w m/s² |
+|---|---|---|---|
+| 0.25 | 0.30 | 1.0655 | 0.5328 |
+| 0.50 | 0.60 | 1.3038 | 0.6519 |
+| 0.75 | 0.90 | 1.8535 | 0.9267 |
+| 1.00 | 1.20 | 2.2361 | 1.1180 |
+| 1.25 | 1.50 | 1.4024 | 0.7012 |
+| 1.50 | 1.80 | 0.8575 | 0.4287 |
+| 2.00 | 2.40 | 0.4472 | 0.2236 |
+| 3.00 | 3.60 | 0.2215 | 0.1107 |
+| 5.00 | 6.00 | 0.1116 | 0.0558 |
+| 10.00 | 12.00 | 0.0514 | 0.0257 |
+
+注意 r = 1(激励频率等于固有频率)时 T 是 2.236,但**真正的峰值 2.283 出现在
+r ≈ 0.949**,略低于共振比 —— 阻尼越大,峰位越往左偏。这是很多人会算错的地方。
+
+## 四条断言
+
+| 断言 | 判据 | 默认结果 |
+|---|---|---|
+| 共振位置 | 扫描峰位与 `sqrt(1−2ζ²)` 的偏差 ≤ 0.02 | PASS(0.0132) |
+| 峰值倍率 | 扫描峰值与闭式峰值的相对偏差 ≤ 5% | PASS(0.12%) |
+| 高频衰减 | `T(r=10) ≤ 0.1` | PASS(0.0514) |
+| 输入线性 | 输入加倍后 `a_w` 精确加倍 | PASS(0.0000) |
+
+## 参数
+
+| 参数 | 默认 | 说明 |
+|---|---|---|
+| `/suspension/fn_hz` | 1.2 | 悬架固有频率 Hz |
+| `/suspension/damping` | 0.25 | 阻尼比,必须在 (0, 0.7071) 开区间 |
+| `/road/input_accel` | 0.5 | 路面输入加速度 RMS m/s² |
+| `/road/freq_hz` | 6.0 | 关心的激励频率 Hz |
+| `/check/pos_tolerance` | 0.02 | 峰位容差(频率比) |
+| `/check/peak_tolerance` | 0.05 | 峰值相对容差 |
+| `/check/high_freq_limit` | 0.1 | r=10 时传递率上限 |
+| `/check/linear_tolerance` | 0.02 | 输入加倍的线性容差 |
+| `/scan/low` `/scan/high` `/scan/steps` | 0.05 / 4.0 / 400 | 扫描区间与步数 |
+| `/rate/publish_hz` | 1.0 | 保活重发频率 Hz |
+
+## 话题
+
+| 话题 | 类型 | 内容 |
+|---|---|---|
+| `/ride/report` | `std_msgs/String` | 整份报告 |
+| `/ride/curve` | `std_msgs/Float64MultiArray` | 每个频率比三元组 `[r, T, a_w]`,共 30 个数 |
+| `/ride/peak` | `std_msgs/Float64MultiArray` | `[理论峰位, 理论峰值, 扫描峰位, 扫描峰值, 激励处 a_w]` |
+
+三条都是 latched。
+
+## 跑起来
+
+```bash
+cd ~/catkin_ws19 && catkin_make
+source /opt/ros/melodic/setup.bash
+source ~/catkin_ws19/devel/setup.bash
+roslaunch ride_comfort_transmissibility main.launch
+```
+
+默认 `结论:PASSED`。两个有意思的反例:
+
+```bash
+# ① 容差收到 0.001 → 扫描精度不够,只翻「共振位置」
+roslaunch ride_comfort_transmissibility main.launch pos_tolerance:=0.001
+
+# ② 阻尼降到 0.02(坏减振器)→ 峰值 25 倍,激励频率挪到 1.2 Hz 就「无法忍受」
+roslaunch ride_comfort_transmissibility main.launch damping:=0.02 freq_hz:=1.2
+```
+
+反例②很说明问题:四条断言**全部通过**(物理上它自洽),但舒适等级从「舒适」
+变成「无法忍受」。断言管的是「算得对不对」,等级管的是「人坐着难受不难受」。
+
+## 离线测试
+
+```bash
+python3 tests/test_ride_comfort_transmissibility_local.py
+```
+
+覆盖 A 传递率基本形、B 闭式峰位峰值、C 舒适等级、D 四条断言、E 扫描表、
+F 字符图、G 参数读取、H 报告排版、I 闭式核对、J 工程文件约定、K 编码声明回归。
+
+## 与已有模块的分工
+
+| 模块 | 关注点 | 本模块的区别 |
+|---|---|---|
+| `rollover_margin` | 侧翻(横向载荷转移) | 管横向极限,本模块管垂直舒适性 |
+| `lateral_stability_margin` | 不足转向/甩尾 | 管转向响应 |
+| `braking_distance_check` | 纵向停车距离 | 管纵向制动 |
+| `steering_actuator_lag` | 执行器一阶惯性 | 同是「频率响应」,但那是转向机构,本模块是悬架 |
+
+## 常见问题
+
+**1. 为什么峰值不在 r = 1?**
+`T(1) = sqrt(1+(2ζ)²)/(2ζ)`,而真正的极值点在 `r = sqrt(1−2ζ²)`。ζ = 0.25 时
+r_p = 0.935,峰值比 T(1) 高约 2%。阻尼越大偏得越多,这也是判据要写「峰位」
+而不是直接拿 r=1 当峰的原因。
+
+**2. `damping:=0.8` 为什么直接报错?**
+超过 `1/√2 ≈ 0.7071` 以后曲线没有经典共振峰,`sqrt(1−2ζ²)` 是虚数。与其给一个
+错的峰位,不如判参数非法 —— 现实里的悬架阻尼比也不会到 0.8。
+
+**3. 高通/低通行为怎么读?**
+`r → 0` 时 `T → 1`(车身跟着路面一起动,等于没有悬架);`r → ∞` 时
+`T → 0`(悬架把高频震动滤掉了)。所以舒适性设计的目标是把共振峰挪到人最不敏感
+的低频、同时把峰压下去,也就是「加大阻尼」。
+
+## 大模型声明
+
+本模块的代码编写、测试编写与文档整理使用了 AI 编程助手辅助,提交内容由本人负责。
diff --git a/src/ground/ride_comfort_transmissibility/config/ride_comfort_transmissibility.yaml b/src/ground/ride_comfort_transmissibility/config/ride_comfort_transmissibility.yaml
new file mode 100644
index 0000000000..74b2b6e34f
--- /dev/null
+++ b/src/ground/ride_comfort_transmissibility/config/ride_comfort_transmissibility.yaml
@@ -0,0 +1,21 @@
+# ride_comfort_transmissibility 的默认参数
+# 由 launch/main.launch 载入
+
+suspension:
+ fn_hz: 1.2 # 悬架固有频率 Hz
+ damping: 0.25 # 阻尼比(必须在 (0, 0.7071) 开区间)
+
+road:
+ input_accel: 0.5 # 路面输入加速度 RMS m/s^2
+ freq_hz: 6.0 # 关心的路面激励频率 Hz
+
+check:
+ pos_tolerance: 0.02 # 峰位容差(频率比)
+ peak_tolerance: 0.05 # 峰值相对容差
+ high_freq_limit: 0.1 # r=10 时传递率上限
+ linear_tolerance: 0.02 # 输入加倍的线性容差
+
+scan:
+ low: 0.05 # 扫描下限(频率比)
+ high: 4.0 # 扫描上限
+ steps: 400 # 扫描步数
diff --git a/src/ground/ride_comfort_transmissibility/launch/main.launch b/src/ground/ride_comfort_transmissibility/launch/main.launch
new file mode 100644
index 0000000000..7c1a0c919b
--- /dev/null
+++ b/src/ground/ride_comfort_transmissibility/launch/main.launch
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/ground/ride_comfort_transmissibility/package.xml b/src/ground/ride_comfort_transmissibility/package.xml
new file mode 100644
index 0000000000..956c943719
--- /dev/null
+++ b/src/ground/ride_comfort_transmissibility/package.xml
@@ -0,0 +1,18 @@
+
+
+ ride_comfort_transmissibility
+ 1.0.0
+
+ 乘坐舒适性传递率核算:单自由度悬架在路面正弦激励下的位移传递率、
+ 共振峰位置与峰值倍率、ISO 2631-1 舒适度等级,并给出四条断言。
+ 纯标准库实现,不依赖 CARLA、不需要显示器。
+
+
+ Wist-sutton
+ MIT
+
+ catkin
+
+ rospy
+ std_msgs
+
diff --git a/src/ground/ride_comfort_transmissibility/scripts/main.py b/src/ground/ride_comfort_transmissibility/scripts/main.py
new file mode 100644
index 0000000000..946bc28d26
--- /dev/null
+++ b/src/ground/ride_comfort_transmissibility/scripts/main.py
@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""ride_comfort_transmissibility 节点入口:参数、核算、打印、发布。"""
+
+from __future__ import division, print_function, unicode_literals
+
+import os
+import sys
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+if _HERE not in sys.path:
+ sys.path.insert(0, _HERE)
+
+from ride_node import main # noqa: E402
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/src/ground/ride_comfort_transmissibility/scripts/ride_core.py b/src/ground/ride_comfort_transmissibility/scripts/ride_core.py
new file mode 100644
index 0000000000..453b387a25
--- /dev/null
+++ b/src/ground/ride_comfort_transmissibility/scripts/ride_core.py
@@ -0,0 +1,247 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""乘坐舒适性传递率核算(纯标准库,不依赖 ROS / CARLA / numpy)。
+
+问题:车在某个频率的路面激励下,座椅/车身会被放大多少倍?
+共振峰在哪里、有多高?按 ISO 2631 加权后属于哪个舒适度等级?
+
+模型(单自由度基础激励,位移传递率):
+
+ r = f / f_n 频率比
+ T(r) = sqrt((1 + (2ζr)²) /
+ ((1 − r²)² + (2ζr)²)) 传递率(放大倍数)
+
+三条闭式结论,正好用来写断言:
+
+ 峰值位置 r_p = sqrt(1 − 2ζ²) (ζ ≥ 1/√2 时没有峰,T ≡ 1)
+ 峰值大小 T_p = 1 / (2ζ·sqrt(1 − ζ²))
+ 高频衰减 T(r) → 0(r 越大越快趋近,r=10 时约 1/r² 量级)
+
+ISO 2631-1 的舒适度等级按加权加速度 a_w(m/s²,RMS)划分:
+
+ < 0.315 舒适
+ 0.315 ~ 0.63 略有不适
+ 0.63 ~ 1.0 不适
+ 1.0 ~ 1.6 很不适
+ 1.6 ~ 2.5 极不适
+ > 2.5 无法忍受
+"""
+
+from __future__ import division, print_function, unicode_literals
+
+import math
+
+ASSERT_NAMES = (u"共振位置", u"峰值倍率", u"高频衰减", u"输入线性")
+
+# (上限, 等级名),从低到高排列
+COMFORT_SCALE = (
+ (0.315, u"舒适"),
+ (0.63, u"略有不适"),
+ (1.0, u"不适"),
+ (1.6, u"很不适"),
+ (2.5, u"极不适"),
+)
+
+
+class RideError(ValueError):
+ """参数非法。"""
+
+
+def _positive(name, value):
+ if value is None or value <= 0:
+ raise RideError(u"%s 必须大于 0,收到 %r" % (name, value))
+ return value
+
+
+class RideSpec(object):
+ """悬架与激励参数。"""
+
+ def __init__(self, fn_hz=1.2, damping=0.25, input_accel=0.5,
+ road_freq_hz=6.0):
+ self.fn_hz = _positive(u"固有频率", fn_hz)
+ # 上限取 1/sqrt(2)≈0.707:超过它传递率曲线不再有经典共振峰,
+ # 闭式峰位 sqrt(1-2ζ²) 也失去意义,索性判为参数非法。
+ if damping <= 0 or damping >= 1.0 / math.sqrt(2.0):
+ raise RideError(u"阻尼比必须在 (0, 1/sqrt(2)) 开区间,收到 %r"
+ % (damping,))
+ self.damping = damping
+ self.input_accel = _positive(u"输入加速度", input_accel)
+ self.road_freq_hz = _positive(u"路面激励频率", road_freq_hz)
+
+ # ---- 传递率三件套 ----
+ def ratio(self, freq_hz):
+ return freq_hz / self.fn_hz
+
+ def transmissibility(self, freq_hz):
+ r = self.ratio(freq_hz)
+ zeta = self.damping
+ num = 1.0 + (2.0 * zeta * r) ** 2
+ den = (1.0 - r * r) ** 2 + (2.0 * zeta * r) ** 2
+ return math.sqrt(num / den)
+
+ def transmissibility_at_ratio(self, r):
+ return self.transmissibility(r * self.fn_hz)
+
+ def peak_ratio(self):
+ return math.sqrt(1.0 - 2.0 * self.damping ** 2)
+
+ def peak_value(self):
+ """在 r_p = sqrt(1 − 2ζ²) 处取传递率,得到真实的峰值(ζ ≥ 1/√2 时为 1)。"""
+ zeta = self.damping
+ r2 = 1.0 - 2.0 * zeta ** 2
+ w2 = 4.0 * zeta ** 2
+ num = 1.0 + w2 * r2
+ den = w2 * (1.0 - zeta ** 2)
+ return math.sqrt(num / den)
+
+ def weighted_accel(self, freq_hz):
+ return self.transmissibility(freq_hz) * self.input_accel
+
+ def __repr__(self):
+ return ("RideSpec(fn_hz=%.3f, damping=%.3f, input_accel=%.3f)"
+ % (self.fn_hz, self.damping, self.input_accel))
+
+
+def comfort_grade(aw):
+ """把加权加速度(m/s²)换成 ISO 2631 的等级名。"""
+ if aw < 0:
+ raise RideError(u"加权加速度不能为负,收到 %r" % (aw,))
+ for limit, name in COMFORT_SCALE:
+ if aw < limit:
+ return name
+ return u"无法忍受"
+
+
+def scan(spec, ratios):
+ """在给定频率比上取表:[(r, 频率, 传递率, 加权加速度), ...]。"""
+ rows = []
+ for r in ratios:
+ if r <= 0:
+ raise RideError(u"频率比必须大于 0,收到 %r" % (r,))
+ freq = r * spec.fn_hz
+ t = spec.transmissibility_at_ratio(r)
+ rows.append((r, freq, t, t * spec.input_accel))
+ return rows
+
+
+DEFAULT_RATIOS = (0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 2.0, 3.0, 5.0, 10.0)
+
+
+def find_peak(spec, low=0.05, high=4.0, steps=400):
+ """在频率比区间上扫描,返回 (峰值频率比, 峰值传递率)。"""
+ if low <= 0 or high <= low or steps < 2:
+ raise RideError(u"扫描区间非法:low=%r high=%r steps=%r"
+ % (low, high, steps))
+ best_r = low
+ best_t = spec.transmissibility_at_ratio(low)
+ for i in range(steps + 1):
+ r = low + (high - low) * i / steps
+ t = spec.transmissibility_at_ratio(r)
+ if t > best_t:
+ best_r, best_t = r, t
+ return best_r, best_t
+
+
+def check_ride(spec, pos_tolerance=0.02, peak_tolerance=0.05,
+ high_freq_limit=0.1, linear_tolerance=0.02):
+ """四条断言:共振位置、峰值倍率、高频衰减、输入线性。"""
+ asserts = []
+
+ measured_r, measured_t = find_peak(spec)
+ theoretical_r = spec.peak_ratio()
+ pos_error = abs(measured_r - theoretical_r)
+ pos_detail = (u"扫描峰位 r=%.4f,理论 sqrt(1-2ζ²)=%.4f(偏差 %.4f,容差 %.3f)"
+ % (measured_r, theoretical_r, pos_error, pos_tolerance))
+ pos_ok = pos_error <= pos_tolerance + 1e-12
+ asserts.append({"type": ASSERT_NAMES[0], "passed": bool(pos_ok),
+ "detail": pos_detail})
+
+ theoretical_t = spec.peak_value()
+ rel = abs(measured_t - theoretical_t) / max(theoretical_t, 1e-12)
+ asserts.append({
+ "type": ASSERT_NAMES[1],
+ "passed": bool(rel <= peak_tolerance + 1e-12),
+ "detail": (u"扫描峰值 %.4f,理论峰值 %.4f(相对偏差 %.4f,容差 %.2f)"
+ % (measured_t, theoretical_t, rel, peak_tolerance)),
+ })
+
+ far = spec.transmissibility_at_ratio(10.0)
+ asserts.append({
+ "type": ASSERT_NAMES[2],
+ "passed": bool(far <= high_freq_limit + 1e-12),
+ "detail": (u"r=10 时传递率 %.6f,上限 %.3f(高频必须衰减)"
+ % (far, high_freq_limit)),
+ })
+
+ doubled = RideSpec(fn_hz=spec.fn_hz, damping=spec.damping,
+ input_accel=2.0 * spec.input_accel)
+ base = spec.weighted_accel(spec.road_freq_hz)
+ dbl = doubled.weighted_accel(spec.road_freq_hz)
+ rel_lin = abs(dbl - 2.0 * base) / max(2.0 * base, 1e-12)
+ asserts.append({
+ "type": ASSERT_NAMES[3],
+ "passed": bool(rel_lin <= linear_tolerance + 1e-12),
+ "detail": (u"输入 %.2f → 加权 %.4f;输入加倍 → 加权 %.4f(相对偏差 %.4f)"
+ % (spec.input_accel, base, dbl, rel_lin)),
+ })
+ return asserts
+
+
+def render_transmissibility(spec, ratios=DEFAULT_RATIOS, width=40):
+ """按传递率画横向条形图(以峰值为满条)。"""
+ peak = spec.peak_value()
+ peak = peak if peak > 0 else 1.0
+ lines = [u"传递率曲线(峰值 = 满条)", "-" * (width + 16)]
+ for r, freq, t, aw in scan(spec, ratios):
+ cells = int(round(t / peak * width))
+ mark = u" <峰值" if abs(r - spec.peak_ratio()) < 0.13 else u""
+ lines.append(u"r=%4.2f f=%5.2fHz |%s| T=%.3f%s"
+ % (r, freq, "#" * cells, t, mark))
+ lines.append("-" * (width + 16))
+ return "\n".join(lines)
+
+
+def format_report(spec, asserts, ratios=DEFAULT_RATIOS):
+ """把参数、扫描表、断言与结论排成报告。"""
+ lines = []
+ peak_r, peak_t = find_peak(spec)
+ lines.append(u"悬架:固有频率 %.3f Hz,阻尼比 %.3f,路面激励 %.2f Hz,输入 %.2f m/s²"
+ % (spec.fn_hz, spec.damping, spec.road_freq_hz,
+ spec.input_accel))
+ lines.append(u"理论:峰位 r=%.4f,峰值 %.4f;ζ=%.3f"
+ % (spec.peak_ratio(), spec.peak_value(), spec.damping))
+ lines.append(u"扫描:峰位 r=%.4f,峰值 %.4f" % (peak_r, peak_t))
+ aw = spec.weighted_accel(spec.road_freq_hz)
+ lines.append(u"舒适性:加权加速度 %.3f m/s² → 等级「%s」"
+ % (aw, comfort_grade(aw)))
+ lines.append(u"频率比 频率(Hz) 传递率 加权(m/s²)")
+ for r, freq, t, a in scan(spec, ratios):
+ lines.append(u"%6.2f %8.3f %6.3f %8.3f" % (r, freq, t, a))
+ lines.append(u"断言:%d 通过 / %d 失败(共 %d 条)"
+ % (len([a for a in asserts if a["passed"]]),
+ len([a for a in asserts if not a["passed"]]), len(asserts)))
+ for a in asserts:
+ lines.append(u" [%s] %s %s" % (u"PASS" if a["passed"] else u"FAIL",
+ a["type"], a["detail"]))
+ ok = all(a["passed"] for a in asserts)
+ lines.append(u"结论:%s" % (u"PASSED" if ok else u"FAILED"))
+ return "\n".join(lines)
+
+
+class RideParams(object):
+ """把 /xxx/yyy 形式的参数名收成对象,缺省时用内置默认值。"""
+
+ def __init__(self, **kwargs):
+ self.spec = RideSpec(
+ fn_hz=kwargs.get("suspension/fn_hz", 1.2),
+ damping=kwargs.get("suspension/damping", 0.25),
+ input_accel=kwargs.get("road/input_accel", 0.5),
+ road_freq_hz=kwargs.get("road/freq_hz", 6.0),
+ )
+ self.pos_tolerance = kwargs.get("check/pos_tolerance", 0.02)
+ self.peak_tolerance = kwargs.get("check/peak_tolerance", 0.05)
+ self.high_freq_limit = kwargs.get("check/high_freq_limit", 0.1)
+ self.linear_tolerance = kwargs.get("check/linear_tolerance", 0.02)
+ self.scan_low = kwargs.get("scan/low", 0.05)
+ self.scan_high = kwargs.get("scan/high", 4.0)
+ self.scan_steps = int(kwargs.get("scan/steps", 400))
diff --git a/src/ground/ride_comfort_transmissibility/scripts/ride_node.py b/src/ground/ride_comfort_transmissibility/scripts/ride_node.py
new file mode 100644
index 0000000000..a459e1837a
--- /dev/null
+++ b/src/ground/ride_comfort_transmissibility/scripts/ride_node.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""ride_comfort_transmissibility 的 ROS 节点。
+
+发给 rospy 的日志必须是 byte str,统一走 _log()。
+"""
+
+from __future__ import division, print_function, unicode_literals
+
+import os
+import sys
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+if _HERE not in sys.path:
+ sys.path.insert(0, _HERE)
+
+import ride_core as core # noqa: E402
+
+
+def _log(level, msg):
+ """把 unicode 消息转成 byte str 再交给 rospy。"""
+ import rospy
+ text = msg.encode("utf-8") if isinstance(msg, type(u"")) else msg
+ if level == "warn":
+ rospy.logwarn(text)
+ elif level == "err":
+ rospy.logerr(text)
+ else:
+ rospy.loginfo(text)
+
+
+def main(argv=None):
+ import rospy
+ import std_msgs.msg as std_msg
+
+ rospy.init_node("ride_comfort_transmissibility", anonymous=False)
+
+ def par(name, default):
+ return rospy.get_param(name, default)
+
+ params = core.RideParams(
+ **{
+ "suspension/fn_hz": par("/suspension/fn_hz", 1.2),
+ "suspension/damping": par("/suspension/damping", 0.25),
+ "road/input_accel": par("/road/input_accel", 0.5),
+ "road/freq_hz": par("/road/freq_hz", 6.0),
+ "check/pos_tolerance": par("/check/pos_tolerance", 0.02),
+ "check/peak_tolerance": par("/check/peak_tolerance", 0.05),
+ "check/high_freq_limit": par("/check/high_freq_limit", 0.1),
+ "check/linear_tolerance": par("/check/linear_tolerance", 0.02),
+ "scan/low": par("/scan/low", 0.05),
+ "scan/high": par("/scan/high", 4.0),
+ "scan/steps": par("/scan/steps", 400),
+ }
+ )
+
+ spec = params.spec
+ peak_r, peak_t = core.find_peak(spec, params.scan_low, params.scan_high,
+ params.scan_steps)
+ asserts = core.check_ride(
+ spec,
+ pos_tolerance=params.pos_tolerance,
+ peak_tolerance=params.peak_tolerance,
+ high_freq_limit=params.high_freq_limit,
+ linear_tolerance=params.linear_tolerance,
+ )
+
+ report = core.format_report(spec, asserts)
+ _log("info", report)
+ _log("info", core.render_transmissibility(spec))
+
+ pub_report = rospy.Publisher("/ride/report", std_msg.String,
+ queue_size=1, latch=True)
+ pub_curve = rospy.Publisher("/ride/curve", std_msg.Float64MultiArray,
+ queue_size=1, latch=True)
+ pub_peak = rospy.Publisher("/ride/peak", std_msg.Float64MultiArray,
+ queue_size=1, latch=True)
+
+ report_msg = std_msg.String()
+ report_msg.data = report
+ pub_report.publish(report_msg)
+
+ curve_msg = std_msg.Float64MultiArray()
+ curve = []
+ for r, freq, t, aw in core.scan(spec, core.DEFAULT_RATIOS):
+ curve.extend([r, t, aw])
+ curve_msg.data = curve
+ pub_curve.publish(curve_msg)
+
+ peak_msg = std_msg.Float64MultiArray()
+ peak_msg.data = [spec.peak_ratio(), spec.peak_value(), peak_r, peak_t,
+ spec.weighted_accel(spec.road_freq_hz)]
+ pub_peak.publish(peak_msg)
+
+ passed = len([a for a in asserts if a["passed"]])
+ _log("info", u"已发布 /ride/report、/ride/curve、/ride/peak"
+ u"(断言 %d/%d,激励处等级「%s」)"
+ % (passed, len(asserts),
+ core.comfort_grade(spec.weighted_accel(spec.road_freq_hz))))
+
+ rate = rospy.Rate(par("/rate/publish_hz", 1.0))
+ while not rospy.is_shutdown():
+ pub_report.publish(report_msg)
+ pub_curve.publish(curve_msg)
+ pub_peak.publish(peak_msg)
+ rate.sleep()
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/tests/test_ride_comfort_transmissibility_local.py b/tests/test_ride_comfort_transmissibility_local.py
new file mode 100644
index 0000000000..9eac9d646c
--- /dev/null
+++ b/tests/test_ride_comfort_transmissibility_local.py
@@ -0,0 +1,372 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""ride_comfort_transmissibility 模块的离线回归测试。
+
+特点:
+* 只用 Python 标准库,**不需要 ROS、不需要 CARLA、不需要显示器**
+* 同时兼容 Python 2.7 与 Python 3.x
+* 在仓库根目录执行:python3 tests/test_ride_comfort_transmissibility_local.py
+
+覆盖范围:
+A 传递率基本形 B 闭式峰位峰值 C 舒适等级 D 四条断言
+E 扫描表 F 字符图 G 参数读取 H 报告排版
+I 闭式核对 J 工程文件约定 K 编码声明回归
+"""
+
+from __future__ import division, print_function, unicode_literals
+
+import io
+import math
+import os
+import sys
+
+try: # Python 2 兼容
+ text_type = unicode # noqa: F821
+except NameError:
+ text_type = str
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ROOT = os.path.dirname(HERE)
+
+PKG = os.path.join(ROOT, "src", "ground", "ride_comfort_transmissibility")
+SCRIPTS = os.path.join(PKG, "scripts")
+
+if SCRIPTS not in sys.path:
+ sys.path.insert(0, SCRIPTS)
+
+import ride_core as core # noqa: E402
+
+FAILS = []
+OK = [0]
+
+
+def out(text):
+ if isinstance(text, text_type):
+ sys.stdout.write(text + u"\n")
+ else:
+ sys.stdout.write(text + "\n")
+
+
+def check(name, cond, detail=""):
+ OK[0] += 1
+ if cond:
+ out(u" ok %s" % name)
+ else:
+ out(u" FAIL %s %s" % (name, detail))
+ FAILS.append(name)
+
+
+def near(a, b, tol=1e-9):
+ return abs(a - b) <= tol
+
+
+def raises(exc, func, *args, **kwargs):
+ try:
+ func(*args, **kwargs)
+ except exc:
+ return True
+ except Exception:
+ return False
+ return False
+
+
+# ------------------------------------------------------------ A 传递率基本形
+def group_shape():
+ out(u"A 传递率基本形")
+ spec = core.RideSpec()
+ check(u"A1 零频传递率为 1",
+ near(spec.transmissibility_at_ratio(1e-6), 1.0, 1e-6),
+ repr(spec.transmissibility_at_ratio(1e-6)))
+ check(u"A2 共振比处 T=2.236", near(spec.transmissibility_at_ratio(1.0), 2.236068, 1e-6))
+ check(u"A3 半频比处 T=1.304", near(spec.transmissibility_at_ratio(0.5), 1.303840, 1e-6))
+ check(u"A4 两倍频比处 T=0.447", near(spec.transmissibility_at_ratio(2.0), 0.447214, 1e-6))
+ check(u"A5 十倍频比处 T=0.0514", near(spec.transmissibility_at_ratio(10.0), 0.051440, 1e-6))
+ check(u"A6 峰前单调增",
+ spec.transmissibility_at_ratio(0.3) < spec.transmissibility_at_ratio(0.6)
+ < spec.transmissibility_at_ratio(0.9))
+ check(u"A7 峰后单调减",
+ spec.transmissibility_at_ratio(1.2) > spec.transmissibility_at_ratio(1.8)
+ > spec.transmissibility_at_ratio(3.0))
+ check(u"A8 峰值大于共振比处值",
+ spec.peak_value() > spec.transmissibility_at_ratio(1.0))
+ check(u"A9 频率比可换算", near(spec.ratio(2.4), 2.0, 1e-12))
+ check(u"A10 传递率恒为正",
+ all(spec.transmissibility_at_ratio(r) > 0 for r in core.DEFAULT_RATIOS))
+
+
+# ------------------------------------------------------------ B 闭式峰位峰值
+def group_peak():
+ out(u"B 闭式峰位峰值")
+ spec = core.RideSpec()
+ check(u"B1 峰位闭式 sqrt(1-2ζ²)",
+ near(spec.peak_ratio(), math.sqrt(1 - 2 * 0.25 ** 2), 1e-12))
+ check(u"B2 峰位数值", near(spec.peak_ratio(), 0.935414, 1e-6))
+ check(u"B3 峰值数值", near(spec.peak_value(), 2.280351, 1e-6))
+ peak_r, peak_t = core.find_peak(spec)
+ check(u"B4 扫描峰位", near(peak_r, 0.948625, 1e-6))
+ check(u"B5 扫描峰值", near(peak_t, 2.283149, 1e-6))
+ check(u"B6 扫描峰值与闭式相对偏差 < 1%",
+ abs(peak_t - spec.peak_value()) / spec.peak_value() < 0.01)
+ check(u"B7 扫描峰位与闭式偏差 < 容差",
+ abs(peak_r - spec.peak_ratio()) < 0.02)
+ check(u"B8 阻尼变大峰值变小",
+ core.RideSpec(damping=0.4).peak_value() < spec.peak_value())
+ check(u"B9 阻尼变小峰值变大",
+ core.RideSpec(damping=0.1).peak_value() > spec.peak_value())
+ check(u"B10 扫描区间非法被拒",
+ raises(core.RideError, core.find_peak, spec, 0.0, 1.0, 10))
+
+
+# ------------------------------------------------------------ C 舒适等级
+def group_grade():
+ out(u"C 舒适等级")
+ check(u"C1 0.3 舒适", core.comfort_grade(0.3) == u"舒适", core.comfort_grade(0.3))
+ check(u"C2 0.315 边界进下一档",
+ core.comfort_grade(0.315) == u"略有不适")
+ check(u"C3 0.5 略有不适", core.comfort_grade(0.5) == u"略有不适")
+ check(u"C4 0.8 不适", core.comfort_grade(0.8) == u"不适")
+ check(u"C5 1.2 很不适", core.comfort_grade(1.2) == u"很不适")
+ check(u"C6 2.0 极不适", core.comfort_grade(2.0) == u"极不适")
+ check(u"C7 3.0 无法忍受", core.comfort_grade(3.0) == u"无法忍受")
+ check(u"C8 负值被拒", raises(core.RideError, core.comfort_grade, -0.1))
+ check(u"C9 等级单调",
+ core.comfort_grade(0.2) == u"舒适"
+ and core.comfort_grade(2.4) == u"极不适")
+ check(u"C10 默认工况等级",
+ core.comfort_grade(core.RideSpec().weighted_accel(6.0)) == u"舒适")
+
+
+# ------------------------------------------------------------ D 四条断言
+def group_asserts():
+ out(u"D 四条断言")
+ spec = core.RideSpec()
+ asserts = core.check_ride(spec)
+ check(u"D1 断言条数为 4", len(asserts) == 4, repr(len(asserts)))
+ check(u"D2 断言名齐全",
+ tuple(a["type"] for a in asserts) == core.ASSERT_NAMES,
+ repr([a["type"] for a in asserts]))
+ check(u"D3 默认全部通过", all(a["passed"] for a in asserts),
+ repr([a["type"] for a in asserts if not a["passed"]]))
+ check(u"D4 每条有 detail",
+ all(isinstance(a["detail"], (u"").__class__) and a["detail"]
+ for a in asserts))
+ check(u"D5 共振位置 detail 含扫描值", u"0.9486" in asserts[0]["detail"])
+ check(u"D6 峰值 detail 含闭式值", u"2.2804" in asserts[1]["detail"])
+ check(u"D7 高频 detail 含 10 倍频", u"r=10" in asserts[2]["detail"])
+ check(u"D8 线性 detail 含加倍",
+ u"加倍" in asserts[3]["detail"], asserts[3]["detail"])
+
+ tight = core.check_ride(spec, pos_tolerance=0.001)
+ flipped = [a["type"] for a in tight if not a["passed"]]
+ check(u"D9 收紧位置容差只翻共振位置",
+ flipped == [core.ASSERT_NAMES[0]], repr(flipped))
+
+ strict = core.check_ride(spec, high_freq_limit=0.001)
+ flipped = [a["type"] for a in strict if not a["passed"]]
+ check(u"D10 收紧高频上限只翻高频衰减",
+ flipped == [core.ASSERT_NAMES[2]], repr(flipped))
+
+ soft = core.check_ride(core.RideSpec(damping=0.02))
+ check(u"D11 软阻尼下四条仍全过", all(a["passed"] for a in soft))
+
+
+# ------------------------------------------------------------ E 扫描表
+def group_scan():
+ out(u"E 扫描表")
+ spec = core.RideSpec()
+ rows = core.scan(spec, core.DEFAULT_RATIOS)
+ check(u"E1 行数", len(rows) == 10, repr(len(rows)))
+ check(u"E2 首行频率比", near(rows[0][0], 0.25))
+ check(u"E3 末行频率比", near(rows[-1][0], 10.0))
+ check(u"E4 频率换算", near(rows[3][1], 1.2, 1e-12))
+ check(u"E5 共振比行传递率", near(rows[3][2], 2.236068, 1e-6))
+ check(u"E6 加权等于传递率乘输入",
+ all(near(r[3], r[2] * spec.input_accel, 1e-12) for r in rows))
+ check(u"E7 峰值出现在 0.75~1.25 之间",
+ rows[2][2] < rows[3][2] and rows[4][2] < rows[3][2])
+ check(u"E8 非法频率比被拒",
+ raises(core.RideError, core.scan, spec, (0.0,)))
+ check(u"E9 自定义频率比可用",
+ len(core.scan(spec, (1.0, 2.0, 3.0))) == 3)
+
+
+# ------------------------------------------------------------ F 字符图
+def group_render():
+ out(u"F 字符图")
+ art = core.render_transmissibility(core.RideSpec())
+ lines = art.split("\n")
+ check(u"F1 有标题", u"传递率曲线" in lines[0], lines[0])
+ check(u"F2 有分隔线", lines[1].startswith("-") and lines[-1].startswith("-"))
+ check(u"F3 数据行数 10", len(lines) == 13, repr(len(lines)))
+ check(u"F4 共振行有峰值标记", any(u"<峰值" in ln for ln in lines))
+ bars = [ln.count("#") for ln in lines[2:-1]]
+ check(u"F5 条形最宽在峰值行", bars.index(max(bars)) == 3, repr(bars))
+ check(u"F6 宽度可调",
+ max(ln.count("#") for ln in
+ core.render_transmissibility(core.RideSpec(), width=12).split("\n")) <= 12)
+
+
+# ------------------------------------------------------------ G 参数读取
+def group_params():
+ out(u"G 参数读取")
+ params = core.RideParams()
+ check(u"G1 默认固有频率", near(params.spec.fn_hz, 1.2))
+ check(u"G2 默认阻尼比", near(params.spec.damping, 0.25))
+ check(u"G3 默认输入", near(params.spec.input_accel, 0.5))
+ check(u"G4 默认激励频率", near(params.spec.road_freq_hz, 6.0))
+ check(u"G5 默认位置容差", near(params.pos_tolerance, 0.02))
+ check(u"G6 默认峰值容差", near(params.peak_tolerance, 0.05))
+ check(u"G7 默认高频上限", near(params.high_freq_limit, 0.1))
+ check(u"G8 默认线性容差", near(params.linear_tolerance, 0.02))
+
+ custom = core.RideParams(**{
+ "suspension/fn_hz": 1.6,
+ "suspension/damping": 0.3,
+ "road/input_accel": 0.8,
+ "check/high_freq_limit": 0.2,
+ })
+ check(u"G9 固有频率可覆盖", near(custom.spec.fn_hz, 1.6))
+ check(u"G10 阻尼可覆盖", near(custom.spec.damping, 0.3))
+ check(u"G11 输入可覆盖", near(custom.spec.input_accel, 0.8))
+ check(u"G12 阈值可覆盖", near(custom.high_freq_limit, 0.2))
+ check(u"G13 未覆盖项保持默认", near(custom.spec.road_freq_hz, 6.0))
+ check(u"G14 非法阻尼被拒",
+ raises(core.RideError, core.RideSpec, damping=0.0))
+ check(u"G15 过大阻尼被拒",
+ raises(core.RideError, core.RideSpec, damping=0.75))
+ check(u"G16 非法固有频率被拒",
+ raises(core.RideError, core.RideSpec, fn_hz=-1.0))
+
+
+# ------------------------------------------------------------ H 报告排版
+def group_report():
+ out(u"H 报告排版")
+ spec = core.RideSpec()
+ asserts = core.check_ride(spec)
+ text = core.format_report(spec, asserts)
+ check(u"H1 含悬架行", u"悬架:固有频率 1.200 Hz" in text)
+ check(u"H2 含理论行", u"理论:峰位 r=0.9354,峰值 2.2804" in text)
+ check(u"H3 含扫描行", u"扫描:峰位 r=0.9486" in text)
+ check(u"H4 含舒适性行", u"等级「舒适」" in text)
+ check(u"H5 含断言汇总", u"断言:4 通过 / 0 失败(共 4 条)" in text)
+ check(u"H6 含结论 PASSED", u"结论:PASSED" in text)
+ check(u"H7 每条断言都出现", all(a["type"] in text for a in asserts))
+ rows = [line for line in text.split(u"\n")
+ if line.strip().startswith((u"0.25", u"0.50", u"0.75", u"1.00",
+ u"1.25", u"1.50", u"2.00", u"3.00",
+ u"5.00", u"10.00"))]
+ check(u"H8 表格有 10 行数据",
+ len(rows) == 10 and u"10.00" in text and u"12.000" in text)
+
+ bad = core.format_report(spec, core.check_ride(spec, pos_tolerance=0.001))
+ check(u"H9 反例结论 FAILED", u"结论:FAILED" in bad)
+ check(u"H10 反例含 1 失败", u"断言:3 通过 / 1 失败" in bad)
+
+
+# ------------------------------------------------------------ I 闭式核对
+def group_identity():
+ out(u"I 闭式核对")
+ spec = core.RideSpec()
+ zeta = spec.damping
+ # r=1 处的解析值:sqrt(1+(2ζ)²)/(2ζ)
+ analytic = math.sqrt(1 + (2 * zeta) ** 2) / (2 * zeta)
+ check(u"I1 共振比处解析值", near(spec.transmissibility_at_ratio(1.0), analytic, 1e-12))
+ # 峰位处解析值(与 peak_value 同源,但用另一条式子写)
+ r = spec.peak_ratio()
+ alt = math.sqrt((1 + (2 * zeta * r) ** 2) /
+ ((1 - r * r) ** 2 + (2 * zeta * r) ** 2))
+ check(u"I2 峰值与峰位处取值一致", near(alt, spec.peak_value(), 1e-12))
+ # 高频渐近:ζ 很小时 T(10) ≈ 1/(100−1)
+ tiny = core.RideSpec(damping=1e-4)
+ check(u"I3 高频渐近 1/(r²-1)",
+ near(tiny.transmissibility_at_ratio(10.0), 1.0 / 99.0, 2e-3),
+ repr(tiny.transmissibility_at_ratio(10.0)))
+ # 加权线性
+ a1 = spec.weighted_accel(2.4)
+ a2 = core.RideSpec(input_accel=1.0).weighted_accel(2.4)
+ check(u"I4 输入加倍加权加倍", near(a2, 2 * a1, 1e-12))
+ # 固有频率只改变频率轴,不改变传递率
+ other = core.RideSpec(fn_hz=2.4)
+ check(u"I5 固有频率不改变传递率",
+ near(other.transmissibility(2.4), spec.transmissibility(1.2), 1e-12))
+ check(u"I6 峰值与阻尼反相关",
+ core.RideSpec(damping=0.05).peak_value()
+ > core.RideSpec(damping=0.5).peak_value())
+
+
+# ------------------------------------------------------------ J 工程文件约定
+def group_files():
+ out(u"J 工程文件约定")
+ for rel in ("CMakeLists.txt", "package.xml", "README.md",
+ "config/ride_comfort_transmissibility.yaml", "launch/main.launch",
+ "scripts/main.py", "scripts/ride_core.py",
+ "scripts/ride_node.py"):
+ check(u"J %s 存在" % rel, os.path.isfile(os.path.join(PKG, rel)))
+
+ launch = io.open(os.path.join(PKG, "launch", "main.launch"),
+ encoding="utf-8").read()
+ check(u"J launch 有 rosparam load", u'= 12", launch.count("= 12,
+ repr(launch.count("