数值模拟 on Keqi的博客

GASPHiA中的自引力树代码效率与优化分析

plloningye@gmail.com (Keqi Ye) — Tue, 07 Apr 2026 14:00:00 +0800

500万粒子纯引力 N-Body 模拟：星系碰撞产生的潮汐尾结构本模拟采用 GASPHiA 的纯 N 体模块实现。初始模型通过开源工具 DICE 构建，包含了完整的暗物质晕（DM Halo）与恒星盘（Stellar Disk）组分。重点展示了在引力相互作用下，星系盘部粒子受扰动演化出典型潮汐尾（Tidal Tails）的过程。

为什么需要考虑引力？

在天体物理的 SPH 模拟中，除了撞击过程本身，星体自身的引力对最终结果的影响同样至关重要。这也解释了为什么在模拟固态行星的撞击时，我们往往不引入物质强度模型，而是将其近似为纯粹的流体来处理。对于某些巨型撞击模拟而言，引力的作用不仅体现在模拟过程中需要实时计算引力，甚至在预处理阶段就必须求解泊松方程，以构建一个处于引力平衡状态的初始天体，再将其投入撞击计算。

这里所说的引力，即自引力，指的是 SPH 粒子之间由于质量分布而产生的相互吸引力。这与模拟水动力学现象（如溃坝）时所采用的引力模型截然不同——后者仅需为每个粒子统一施加一个指向地面的恒定加速度即可。

如何计算自引力，为什么需要树代码？

在 SPH 模拟中，自引力的计算本质上是对每一个粒子求解其所受的引力合力。根据万有引力定律，任意两个粒子之间都存在引力作用，这意味着对于包含 $N$ 个粒子的系统，直接计算所有粒子对的相互作用需要 $O(N^2)$ 次运算。当天体物理模拟的粒子数量达到百万甚至千万级别时，这种直接求和的方式在计算量上将变得完全不可接受。

这正是引入 Tree Code（树代码） 的核心动机。树代码的核心思想源于一个朴素的物理直觉：当一个远方的粒子团簇距离我们足够远时，我们无需逐一计算团簇内每个粒子的贡献，而是可以将整个团簇近似视为一个位于其质心的等效质点。通过这种近似，计算复杂度可以从 $O(N^2)$ 大幅降低至 $O(N\log N)$。

Tree Code（树代码）最初由 Barnes 和 Hut 提出[1]，因此基于该文献实现的树结构通常被称为 Barnes-Hut Tree。GASPHiA 在面向 CUDA 架构实现这一数据结构时，借鉴了文献[2]中的并行实现方案。

然而，文献[2]的方法直接服务于纯粹的 N 体模拟，其数据结构仅需满足自引力计算的需求；而 SPH 方法除了计算自引力外，还需依赖树结构进行高效的邻近粒子搜索。这一根本性的需求差异，导致 GASPHiA 最终的树代码结构与文献[2]存在显著不同。具体差异主要体现在两个方面：一是树节点中子节点（Child）数量的管理策略；二是在并行遍历树结构时的线程束投票机制——文献[2]仅需判定引力相互作用的条件，而 GASPHiA 作为SPH代码，必须额外融合邻近搜索的判定逻辑。

尽管在实现细节上存在上述分歧，二者在核心的空间递归划分思路上仍保持高度一致。因此，读者仍可将文献[2]作为理解底层空间划分逻辑的重要参考。

效率对比与优化

背景

目前 GASPHiA 虽然已经实现了基于 Barnes-Hut Tree 的自引力计算。但是与文献[2]相比，在遍历树的时候，由于没有对粒子进行空间排序，因此效率肯定没有经过空间排序的效率高。为了直观展示 Barnes-Hut Tree 的威力，我们实现了暴力双循环计算自引力作为一个参考，同时以不使用空间排序的效率作为基准，探讨最终包含排序过程后的自引力计算的效率提升。

计算核函数

基于树的自引力计算核包含以下几个：

重置树结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


void SPHOctree::resetOctree()
{
 resetOctreeKernel<<<numBlocks, ThreadsPerBlock>>>(
 this->d_child,
 this->d_count,
 this->d_start,
 this->d_sorted,
 this->d_node_com_mass,
 this->d_node_hmax,
 this->d_mutex,
 this->d_node_index,
 this->num_particles,
 this->max_nodes);

 CUDA_CHECK(cudaGetLastError());
}

计算粒子边界

1
2
3
4
5
6
7
8


void SPHOctree::computeBoundingBox(RealType4 *d_particles)
{
 computeMin(d_particles, d_reduceTmp, num_particles, d_bounding_box_min);
 computeMax(d_particles, d_reduceTmp, num_particles, d_bounding_box_max);

 CUDA_CHECK(cudaDeviceSynchronize());
 CUDA_CHECK(cudaGetLastError());
}

自顶向下建立树

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


void SPHOctree::buildTree(RealType4 *d_positions)
{
 buildTreeKernel<<<numBlocks, ThreadsPerBlock>>>(
 d_positions,
 this->d_node_com_mass,
 this->d_count,
 this->d_start,
 this->d_child,
 this->d_node_index,
 this->d_bounding_box_min,
 this->d_bounding_box_max,
 this->num_particles,
 this->max_nodes
 );

 CUDA_CHECK(cudaGetLastError());
 CUDA_CHECK(cudaDeviceSynchronize());
}

计算节点质心

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


void SPHOctree::computeCenterOfMass()
{
 computeCenterOfMassKernel<<<numBlocks, ThreadsPerBlock>>>(
 this->d_node_com_mass,
 this->d_node_index,
 this->num_particles);

 CUDA_CHECK(cudaGetLastError());
 CUDA_CHECK(cudaDeviceSynchronize());
}

计算自引力

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


computeGravityKernel<<<numBlocks, ThreadsPerBlock>>>(
 d_positions,
 this->d_node_com_mass,
 this->d_child,
 d_accelerations,
 this->d_bounding_box_min,
 this->d_bounding_box_max,
 this->num_particles,
 this->theta * this->theta,
 this->constG);

性能瓶颈分析

根据文献[2]的实现，整个树代码流程中最耗时的部分在于最后一步——遍历树结构以计算自引力。其根本原因在于线程访问模式与数据空间分布的错配：若未对粒子数据进行显式排序，处于同一 Warp 中的粒子在物理空间上可能相距甚远。这种空间分布的离散性会直接导致 Warp 内部的线程在执行剪枝判定时产生严重分歧：

1
2
3
4
5


bool mac_satisfied = (child < n) || (!is_active) || (w_sq / theta_sq < r_sq);
if (__all_sync(0xffffffff, mac_satisfied))
{
 // 剪枝
}

当同一 Warp 内的不同粒子面对各自不同的目标节点时，部分线程可能满足剪枝条件（mac_satisfied 为 true），而其余线程则仍需继续深入遍历（false）。由于 CUDA 的 Warp 执行遵循单指令多线程模型，所有线程必须同步执行同一指令路径。因此，只要 Warp 中存在任意一个线程不满足剪枝条件——即便多数线程本可以提前终止——整个 Warp 都必须进入后续的节点下钻流程。这种由线程间数据依赖差异导致的执行路径分叉，大幅削弱了剪枝机制的有效性，使得大量计算资源被耗费在不必要的深层节点访问上。

性能测试与对比

为验证上述分析，我先做了一个测试：通过离散一个正方体获得规则排列的粒子，采用单精度计算，离散得到 100 万个粒子进行测试。测试结果显示，遍历树计算引力确实是最耗时的步骤：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# 规则排列（相当于粗略排序）
Calculating Gravity on GPU (Barnes-Hut, theta=0.5)...
--- Gravity Computation Profiling ---
 resetOctree: 11.6206 ms
 computeBoundingBox: 0.4268 ms
 buildTree: 45.4690 ms
 computeCoM: 0.1025 ms
 computeGravity: 2955.5117 ms
-------------------------------------

# 打乱后（无排序）
--- Gravity Computation Profiling ---
 resetOctree: 10.7203 ms
 computeBoundingBox: 0.4361 ms
 buildTree: 44.1606 ms
 computeCoM: 0.1303 ms
 computeGravity: 202.4100 ms
-------------------------------------

关键发现：时间差距达到 15 倍，区别仅仅在于是否把粒子打乱。如果不打乱，就相当于我们做了排序（因为初始的粒子排布就是规则的）；如果打乱，时间激增。

详细的 Profile 数据如下：

指标名称	指标含义	规则排布	打乱排布
Elapsed Cycles	Kernel 执行消耗的总 GPU 时钟周期数	~0.29 Billion	~2.58 Billion
Duration	Kernel 实际运行时间	~0.19 秒	~3.10 秒
SM Frequency	流式多处理器平均运行频率	~1.55 GHz	~830 MHz
Compute (SM) Throughput	计算单元繁忙程度	~80.4%	~79.2%
Memory Throughput	内存子系统整体繁忙程度	~61.5%	~59.0%
L2 Cache Throughput	L2 缓存访问吞吐率	~23.9%	~14.1%
DRAM Throughput	显存直接访问吞吐率	~0.35%	~15.7%
Achieved Occupancy	实际活跃 Warp 占比	~98.6%	~95.2%

从表中可以清晰看出，打乱后 L2 Cache Throughput 从 23.9% 降至 14.1%，而 DRAM Throughput 从 0.35% 增至 15.7%。这表明粒子排序对于提升数据局部性、充分利用 L2 缓存、减少显存直接访问至关重要，直接导致了 15 倍的性能差距。

排序算法

上一小节通过对输入粒子进行 shuffle 发现：在 CUDA 上实现树算法时，粒子的**空间局部性（Spatial Locality）**起着决定性作用。局部性越好，同一个 Warp 内的 32 个线程在遍历八叉树时，就越容易访问相同的树节点，从而大幅减少 Warp 发散（Warp Divergence），并将 L1/L2 缓存的命中率推向极限，避免对极慢的 DRAM 产生大量直接读写。

注意：这里我虽然用了“减少 Warp 发散（Warp Divergence）”的表达，但其实线程并没有发散，只是打开了过多的节点，某种意义上，相当于warp投票mac_satisfied的不一致性较强，所以我还是借用了 Warp 发散的说法。

然而，在实际的 SPH 或 N-body 模拟中，随着时间的推移，粒子在空间中剧烈碰撞、混合，其在显存数组中的物理索引会与它们真实的几何位置彻底脱节。因此，我们需要在每一帧建树完成后，进行一次高效的空间排序（Spatial Sorting）。

1. 核心思想：利用树拓扑天然排序

既然八叉树本身就是对三维空间的完美网格化划分，那么按照遍历树的顺序（例如深度优先 DFS 或广度优先 BFS）依次读取叶子节点，得到的就是在三维空间中聚拢的粒子序列。

2. Gather 寻址策略：只排索引，不搬数据

在拥有数百万粒子的系统中，如果每次都在全局显存中来回拷贝几十 MB 的粒子坐标（float4 数据），不仅极其耗时，还会额外占用大量显存。采用 Gather 寻址策略:

不移动粒子数据在显存中的排布位置
生成一个一维的映射数组 sort
sort[i] 存放的是"第 i 个线程应该去处理的真实粒子编号"

在后续的引力计算中，同一个 Warp 内的相邻线程将读取 sort 数组中相邻的值，这样同一个warp处理的粒子在空间上都相近了，他们遍历树的路径也大概率会一致。

3. 自顶向下排序

为了在 GPU 上极速完成排序，我们利用建树阶段已经统计好的 count（子树粒子数），采用自顶向下的并行分配机制。父节点会根据各个子节点的 count，为它们在 sort 数组中划分好专属的"内存区间"。

4. Profile 验证

理论上，经过树排序后遍历，路径分化会进一步降低，因为同一个 Warp 的粒子的父节点几乎都在一起。为了量化这种提升，我将粒子数降到 100 万，对以下三种计算模式进行 Profile 分析：

计算模式	描述
1. 完全随机	不使用树排序，粒子顺序在空间上随机分布
2. 初始规则	不使用树排序，粒子顺序在空间上规则排列
3. 树排序	树排序，粒子顺序在空间上随机分布

Profile 命令：

1

ncu --set full -f -o profile/no_shuffle_no_sort_profile -k computeGravityKernel -s 2 -c 2 ./sph_simulator

命令参数说明：

参数	含义
`--set full`	收集所有可用的性能指标
`-f`	强制覆盖已存在的输出文件
`-o profile/xxx`	指定输出文件的路径和名称
`-k computeGravityKernel`	指定要 Profile 的 Kernel 名称
`-s 2`	在程序启动后跳过前 2 次迭代再开始 Profile（避免冷启动影响）
`-c 2`	重复执行 2 次取平均（减少测量误差）

结果对比如下：

计算模式	核心耗时	执行指令数	L1/TEX 命中率	内存吞吐量	Executed IPC	Warp 均指令周期 (CPI)
1. 完全随机	33.13 ms	246.2 亿	48.23%	2.37 GB/s	2.97	13.75 周期
2. 初始规则	5.13 ms	41.9 亿	57.52%	8.14 GB/s	2.99	13.44 周期
3. 树排序	3.11 ms	22.1 亿	58.66%	12.25 GB/s	2.74	13.28 周期

从结果可以看出，树排序模式（3.11 ms）比完全随机模式（33.13 ms）快了约 10 倍，且优于初始规则模式（5.13 ms）。这证明了基于树拓扑的空间排序策略能够显著提升自引力计算的效率。

现在，GASPHiA使用了基于树排序模式优化后的代码。

性能曲线

下面两图展示了在不同粒子数量下，各计算模式的性能对比（线性坐标与对数坐标）：

注意：上图中，“构建树"包含了计算包围盒、排序等所有流程，相较于计算引力或者邻居搜索，建立树的耗时可以忽略。

精度与加速比验证

我还测试了 100 万粒子情况下，Barnes-Hut 算法相对于暴力计算的加速比与误差。注意这里的误差都是相对误差。

不同 $\theta$ 参数下的性能与精度对比：

$\theta$	计算时间 (ms)	最大相对误差	平均相对误差	加速比
0.1	181.877	0.00219153	3.27768e-05	7.42231x
0.2	39.5222	0.00502609	6.86399e-05	34.1566x
0.3	14.9356	0.0214612	0.00015996	90.3847x
0.4	8.75622	0.0335255	0.00028779	154.17x
0.5	5.88032	0.0711218	0.00053247	229.57x
0.6	4.20147	0.0565245	0.000783245	321.303x
0.7	3.52717	0.106591	0.00153542	382.728x
0.8	3.21018	0.170889	0.002965	420.521x

精度验证图：

结论：随着 $\theta$ 增大，计算精度下降（误差增大），但计算速度显著提升。在 $\theta = 0.5$ 时，可以在 200x 加速的同时保持约 7% 的最大相对误差，是较为理想的平衡点。

参考资料

[1] Barnes J, Hut P. A hierarchical O (N log N) force-calculation algorithm. nature. 1986 Dec 4;324(6096):446-9.

[2] Burtscher M, Pingali K. An efficient CUDA implementation of the tree-based barnes hut n-body algorithm. In GPU computing Gems Emerald edition 2011 Jan 1 (pp. 75-92). Morgan Kaufmann.

P-alpha 孔隙度模型的实现与踩坑记录

plloningye@gmail.com (Keqi Ye) — Tue, 07 Apr 2026 14:00:00 +0800

P-alpha 孔隙度模型的实现与踩的一些坑

高孔隙度浮石遭受撞击模拟（2.58 km/s）动画中完全损伤的粒子被移除，模拟只启用了核矫正

GASPHiA 实现了以下两篇论文描述的 P-alpha 模型：

Numerical simulations of impacts involving porous bodies I. Implementing sub-resolution porosity in a 3D SPH hydrocode
Numerical simulations of impacts involving porous bodies: II. Comparison with laboratory experiments

下面就实现过程遇到的问题做一个笔记。

1. 物理问题定义：P-alpha 模型

在多孔材料（如rubble pile、浮石）的冲击动力学中，宏观压力 $P$ 与固相压力 $P_{\text{eos}}$ 以及孔隙度 $\alpha$（也称膨胀度）满足关系：

$$P = \frac{P_{\text{eos}}(\rho_s, e)}{\alpha}$$

其中 $\rho_s = \alpha \rho$ 是固相密度，$\rho$ 是宏观密度，$e$ 是内能。

注意：$\alpha$ 必须大于 1，等于 1 代表这个粒子代表的空间没有空隙。

压实曲线 (Compaction Curve)

材料的压缩过程遵循压实曲线 $\alpha_{\text{curve}}(P)$，定义如下：

阶段	压力范围	公式
弹性阶段	$P \le P_e$	$\alpha = \alpha_0$
塑性压溃阶段	$P_e < P < P_s$	$\displaystyle \alpha = 1.0 + (\alpha_0 - 1.0) \left( \frac{P_s - P}{P_s - P_e} \right)^2$
完全压实阶段	$P \ge P_s$	$\alpha = 1.0$

另外需要注意，孔隙压实是塑性不可逆的。若当前压力导致的理论 $\alpha$ 大于历史最小孔隙度 $\alpha_{\text{old}}$，则取 $\alpha = \alpha_{\text{old}}$。

2. 非线性方程

我们需要寻找一个 $\alpha$，使得它既满足状态方程（EOS）产生的压力，又落在压实曲线上。定义目标函数：

$$F(\alpha) = \alpha - \min\left( \alpha_{\text{curve}}\left( \frac{P_{\text{eos}}(\alpha \rho, e)}{\alpha} \right), \alpha_{\text{old}} \right) = 0$$

式中，$\alpha_{\text{curve}}$ 指的就是压实曲线。

3. 二分法 (Bisection Method)

最简单直观想到的方案就是二分，只是二分法的运行时间可能会稍长一点。

3.1 迭代次数分析

假设对于一个高孔隙材料，初始孔隙度 $\alpha = 4$，对应的物理孔隙率为 $\phi = 1 - 1/\alpha$，即 75%。如果要求迭代最后的收敛精度：

$$\alpha_{n+1} - \alpha_n < \text{tol} = 10^{-12}$$

那么最坏的情况下需要迭代：

$$n \ge \log_2 \left( \frac{L_0}{\text{tol}} \right) = \log_2 \left( \frac{4-1}{10^{-12}} \right)=42$$

3.2 精度要求

值得注意的是：EOS 对密度极度敏感，实际测试过 tol 必须小于 1e-7，这样损伤场才不会产生虚假震荡。这对单精度计算来说是很难达到的，因此GASPH iA的孔隙度模型强制运行在双精度上，但是写回的时候会进行精度调整，适配整体的计算流程。

3.3 性能测试结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


$ grep "calPressureSoundSpeed execution time:" run.log | tail -n 20
calPressureSoundSpeed execution time: 2.882 ms
calPressureSoundSpeed execution time: 2.807 ms
calPressureSoundSpeed execution time: 2.775 ms
calPressureSoundSpeed execution time: 2.766 ms
calPressureSoundSpeed execution time: 2.822 ms
calPressureSoundSpeed execution time: 2.873 ms
calPressureSoundSpeed execution time: 2.766 ms
calPressureSoundSpeed execution time: 2.765 ms
calPressureSoundSpeed execution time: 2.753 ms
calPressureSoundSpeed execution time: 2.774 ms
calPressureSoundSpeed execution time: 2.776 ms
calPressureSoundSpeed execution time: 2.756 ms
calPressureSoundSpeed execution time: 3.197 ms
calPressureSoundSpeed execution time: 2.786 ms
calPressureSoundSpeed execution time: 2.854 ms
calPressureSoundSpeed execution time: 2.885 ms
calPressureSoundSpeed execution time: 2.816 ms
calPressureSoundSpeed execution time: 2.799 ms
calPressureSoundSpeed execution time: 2.787 ms
calPressureSoundSpeed execution time: 2.891 ms
...

1
2
3
4
5
6
7
8
9


$ tail -n 10 run.log
 └─ Sub2: 0.050 ms ( 2.3%)
calPressureSoundSpeed execution time: 2.891 ms
[Step 2273] t=3.200656e-05 | dt=1.761e-08 | Tree=5.467 ms (B: 0.536, S: 4.931, G: 0.000) | Step=15.816 ms | Outputs=7 |
[computeRHS] Total: 2.263 ms
 ├─ Corr: 0.956 ms (42.3%)
 ├─ Sub1: 1.256 ms (55.5%)
 └─ Sub2: 0.050 ms ( 2.2%)
[computeRHS] Total: 2.227 ms

二分法求解 EOS 的运行时间是不可接受的，已经要和计算右端项（单精度）的时间持平了，我们需要收敛更快的算法。

4. 牛顿-拉夫逊法 (Newton-Raphson)

牛顿-拉夫逊法是一种高效的非线性方程求根近似算法。对于一般方程 $f(x) = 0$，假设已知其近似根 $x_n$ 且导数 $f’(x_n) \neq 0$，该方法通过在 $(x_n, f(x_n))$ 处作曲线的切线，用切线与 x 轴的交点作为下一个近似根。其标准的迭代格式为：

$$x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)}$$

牛顿法在根的附近具有二阶收敛的优良特性，即每次迭代的有效数字大约会翻倍，收敛速度远快于二分法。

回到我们的孔隙度模型中，我们要求解的目标方程是 $F(\alpha) = 0$，因此对应的牛顿迭代格式即为：

$$\alpha_{k+1} = \alpha_k - \frac{F(\alpha_k)}{F'(\alpha_k)}$$

为了实现这一迭代过程，核心在于计算目标方程对孔隙度的非线性导数 $F’(\alpha) = \frac{dF}{d\alpha}$。利用链式法则将其展开：

$$\frac{dF}{d\alpha} = 1 - \frac{d\alpha_{\text{curve}}}{dP} \cdot \frac{dP}{d\alpha}$$

4.1 压实曲线导数 $\displaystyle \frac{d\alpha_{\text{curve}}}{dP}$

阶段	导数
弹性或完全压实阶段，或处于卸载状态（$\alpha_{\text{curve}} > \alpha_{\text{old}}$）	$\displaystyle \frac{d\alpha_{\text{curve}}}{dP} = 0$
塑性压溃阶段且处于加载状态时	$\displaystyle \frac{d\alpha_{\text{curve}}}{dP} = -2 \frac{(\alpha_0 - 1.0)(P_s - P)}{(P_s - P_e)^2}$

4.2 压力对孔隙度导数 $\displaystyle \frac{dP}{d\alpha}$

已知 $P = \frac{P_{\text{eos}}(\alpha \rho, e)}{\alpha}$，对 $\alpha$ 求导：

$$\frac{dP}{d\alpha} = \frac{\alpha \cdot \frac{d P_{\text{eos}}}{d\alpha} - P_{\text{eos}}}{\alpha^2}$$

根据链式法则，$\frac{d P_{\text{eos}}}{d\alpha} = \frac{\partial P_{\text{eos}}}{\partial \rho_s} \cdot \frac{d \rho_s}{d\alpha} = \frac{\partial P_{\text{eos}}}{\partial \rho_s} \cdot \rho$。

定义 $\frac{\partial P_{\text{eos}}}{\partial \rho_s}$ 为 dpdrho（由 Tillotson EOS 直接提供），则：

$$\frac{dP}{d\alpha} = \frac{\text{dpdrho} \cdot \rho}{\alpha} - \frac{P}{\alpha}$$

5. 遇到的挑战：震荡

在撞击瞬间，粒子可能处于物理分界线（如弹性极限 $P_e$）附近。

5.1 问题描述

加载步：压力大 $\to$ 导数大 $\to$ 牛顿步过大 $\to$ 跨过分界线进入卸载区。
卸载步：进入卸载区 $\to$ 导数突变为 $0$ $\to$ 修正步直接弹回加载区。

这种由于导数不连续导致的变化造成了牛顿法在两个点之间无限循环，无法收敛。

图中展示的就是模拟初期，某些粒子受到一点点压力之后，牛顿迭代一直震荡无法收敛的情况。

6. 解决方案：安全牛顿法

为了兼顾牛顿法的速度与二分法的稳定性，引入了动态区间收缩的混合算法。

6.1 算法逻辑

步骤	操作
1	维护区间：初始化安全区间 $[a, b] = [1.0, \alpha_{\text{old}}]$
2	区间收紧：若 $F(\alpha_k) > 0$，则令 $b = \alpha_k$；若 $F(\alpha_k) < 0$，则令 $a = \alpha_k$
3	决策拦截：计算牛顿步 $\alpha_{\text{new}} = \alpha_k - \frac{F(\alpha_k)}{F’(\alpha_k)}$，若 $\alpha_{\text{new}}$ 落在开区间 $(a, b)$ 之外，说明牛顿法失效
4	降级处理：此时强行执行二分法 $\alpha_{\text{new}} = \frac{a + b}{2}$
5	保底策略：要是牛顿法在规定的迭代步中没有找到解，那么求解器会调用二分法求解

在相同的初始条件下，相比于震荡情况，现在求解器可以准确跳出震荡区间找到解了。

6.2 性能对比

效率方面比二分法的 2.8ms 左右，快了十倍。相较于求解 SPH 右端项函数的运行时间 2.4ms 左右，EOS 只需要花费其十分之一。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


$ grep "calPressureSoundSpeed" run.log | tail -n 20
calPressureSoundSpeed_newton execution time: 0.237 ms
calPressureSoundSpeed_newton execution time: 0.237 ms
calPressureSoundSpeed_newton execution time: 0.236 ms
calPressureSoundSpeed_newton execution time: 0.236 ms
calPressureSoundSpeed_newton execution time: 0.228 ms
calPressureSoundSpeed_newton execution time: 0.237 ms
calPressureSoundSpeed_newton execution time: 0.242 ms
calPressureSoundSpeed_newton execution time: 0.234 ms
calPressureSoundSpeed_newton execution time: 0.240 ms
calPressureSoundSpeed_newton execution time: 0.231 ms
calPressureSoundSpeed_newton execution time: 0.234 ms
calPressureSoundSpeed_newton execution time: 0.234 ms
calPressureSoundSpeed_newton execution time: 0.233 ms
calPressureSoundSpeed_newton execution time: 0.238 ms
calPressureSoundSpeed_newton execution time: 0.229 ms
calPressureSoundSpeed_newton execution time: 0.236 ms
calPressureSoundSpeed_newton execution time: 0.238 ms
calPressureSoundSpeed_newton execution time: 0.236 ms
calPressureSoundSpeed_newton execution time: 0.239 ms
calPressureSoundSpeed_newton execution time: 0.231 ms
...

1
2
3
4
5
6
7
8


$ tail -n 10 run.log
 └─ Sub2: 0.050 ms ( 2.3%)
[computeRHS] Total: 2.420 ms
 ├─ Press: 0.000 ms ( 0.0%)
 ├─ Corr: 1.026 ms (42.4%)
 ├─ Sub1: 1.352 ms (55.9%)
 └─ Sub2: 0.042 ms ( 1.7%)
calPressureSoundSpeed_newton execution time: 0.207 ms

7. 最终成果与物理验证

7.1 压实曲线验证

图中红色虚线为理论压实曲线，散点为 GASPHiA 的模拟输出。随时间推进，压力导致孔隙正确压实；在压力卸载后，孔隙度严格保持不变，未出现非物理的回弹现象。这从底层印证了 P-alpha 模型的不可逆逻辑实现完全准确。

7.2 宏观实验对比

图 a, b：Jutzi et al. 2009 论文中的实验结果和基准模拟结果。
图 c：GASPHiA 的模拟结果。

可以看到，GASPHiA 输出的物理形态与原始实验及基准论文高度吻合。

对撞击结果进行后处理分析，提取碎片累积质量分布数据：

GASPHiA 计算得到的最大残余碎片质量占比为 8.35%，与实验室给出的真实实验数据 9.96% 误差极小，进一步验证了整个多孔材料求解器核心计算逻辑的可靠性。

SPH基础(四): 状态方程与压力计算

plloningye@gmail.com (Keqi Ye) — Sun, 25 May 2025 00:00:00 +0000

在 SPH 方法中，状态方程（Equation of State, EOS）用于将粒子的密度与压强建立联系，进而计算作用于粒子间的力。

最常用的状态方程是 Tait 方程，其形式为：

$$ P = B\left[\left(\frac{\rho}{\rho_0}\right)^\gamma - 1\right] $$

其中：

$ \rho $ 为当前密度，
$ \rho_0 $ 为参考密度，
$ \gamma $ 为多项式指数（通常为 7），
$ B $ 为常数，决定压缩性。

合理选取 EOS 参数对于模拟结果的稳定性和准确性至关重要。

SPH基础(五): Runge-Kutta自适应时间积分

plloningye@gmail.com (Keqi Ye) — Fri, 24 May 2024 11:00:00 +0800

1. 引言

在流体动力学乃至更广泛的科学计算领域中，光滑粒子流体动力学（Smoothed Particle Hydrodynamics, SPH）是一种强大的无网格拉格朗日方法。SPH模拟的核心之一是对描述系统演化的常微分方程组（ODEs）进行时间积分，以更新每个粒子的物理状态（如位置、速度、内能等）。

传统的时间积分方案（如简单的欧拉法或固定步长的龙格-库塔法）虽然实现简单，但在处理复杂动态过程时面临效率与稳定性的两难困境：

步长过大：可能导致数值不稳定，模拟结果迅速发散，功亏一篑。
步长过小：虽然能保证稳定性，但会极大地增加计算成本，尤其是在模拟过程相对平稳、变化缓慢的阶段，造成了不必要的资源浪费。

为了在保证计算精度的同时最大化效率，自适应步长（Adaptive Time-Stepping） 的积分方法应运而生。本文将详细介绍自适应步长的核心思想，重点讲解龙格-库塔（Runge-Kutta）方法家族中的 RK23 和 RK45 算法，并阐述如何将其与 SPH 的物理计算流程相结合。

2. 龙格-库塔（Runge-Kutta）方法简介

2.1 广义龙格-库塔方法

龙格-库塔方法是一类用于求解常微分方程的、应用广泛的显式和隐式迭代法。其核心思想是通过在当前时间步内评估多个“中间”斜率，并用这些斜率的加权平均值来更新解，从而获得比简单欧拉法更高的精度。

对于一个形如 $\frac{dy}{dt} = f(t, y)$ 的初值问题，一个 $s$ 级的显式RK方法可以表示为：

$$ \begin{aligned} k_1 &= f(t_n, y_n) \\ k_2 &= f(t_n + c_2 h, y_n + h a_{21} k_1) \\ k_3 &= f(t_n + c_3 h, y_n + h (a_{31} k_1 + a_{32} k_2)) \\ &\vdots \\ k_s &= f(t_n + c_s h, y_n + h \sum_{j=1}^{s-1} a_{sj} k_j) \end{aligned} $$

最终的解通过这些中间斜率的加权和来计算：

$$ y_{n+1} = y_n + h \sum_{i=1}^{s} b_i k_i $$

其中 $h$ 是时间步长，系数 $a_{ij}$, $c_i$, 和 $b_i$ 是预先确定的常数，它们的选择决定了方法的精度阶数和稳定性。例如，经典的四阶RK方法（RK4）就是这个家族的一个特例。

2.2 嵌入式RK方法：自适应步长的关键

固定步长的RK方法虽然精度高，但无法感知模拟过程的动态变化。自适应步长的精髓在于“在积分的同时估计误差”。嵌入式龙格-库塔方法（Embedded Runge-Kutta Methods） 正是为此而生。

这类方法（也称 RKF 或 Fehlberg 方法）通过一组精心设计的系数，在一次计算中同时得到两个不同阶数的解：

一个 $p$ 阶精度的解 $y_{n+1}$。
一个 $p-1$ 阶精度的嵌入解 $\hat{y}_{n+1}$。

这两个解共享大部分（甚至全部）的 $k_i$ 计算，因此额外开销很小。它们的差值则可以作为局部截断误差 $E_{n+1}$ 的一个可靠估计：

$$ E_{n+1} = \| y_{n+1} - \hat{y}_{n+1} \| $$

通过将这个误差估计 $E_{n+1}$ 与用户设定的容忍度 tol 进行比较，我们就可以动态地调整时间步长 $h$：

若 $E_{n+1} \le \text{tol}$，则接受当前步（通常使用更高阶的解 $y_{n+1}$），并可尝试在下一步增大大步长。
若 $E_{n+1} > \text{tol}$，则拒绝当前步，缩小步长并重新计算。

RK23 和 RK45 都是这个家族中的杰出代表。

3. 两种经典的自适应RK算法

3.1 RK23 (Bogacki-Shampine) 方法

RK23 方法是一种广泛应用的低阶嵌入式方法，它同时计算一个三阶解和一个二阶嵌入解。

特点：
- 它需要进行3次函数求值（计算 $k_1, k_2, k_3$）来得到一个三阶精度的解。
- 一个二阶精度的解可以通过这些 $k_i$ 的不同线性组合得到，用于误差估计。
- 它具有 FSAL (First Same As Last) 特性：一个步长计算结束时所用的 $k_3$（在新的 $y_{n+1}$ 处的值），可以作为下一个步长的 $k_1$，从而每步实际只需要额外计算2次函数求值，非常高效。
适用场景：
- 对精度要求不是特别苛刻，但希望有自适应步长能力的场景。
- 当函数 $f(t, y)$ 的计算成本较高时，其较少的函数求值次数是一个优势。

其步长调整和误差控制逻辑与高阶方法完全相同，只是系数和阶数不同。

3.2 RK45 (Dormand-Prince 5(4)) 方法

RK45 是自适应积分方法中的“黄金标准”，也是 MATLAB ode45 的默认选择。它通过一次计算得到一个五阶解和一个四阶嵌入解。

核心思想：
- 它需要进行 7 次函数求值（计算 $k_1$ 到 $k_7$）。
- 使用这些 $k_i$ 的线性组合，分别构造出五阶解 $y_{n+1}^{(5)}$ (用于更新状态) 和四阶解 $y_{n+1}^{(4)}$ (用于误差估计)。
- Dormand-Prince 系数经过特别优化，使得误差估计 $| y_{n+1}^{(5)} - y_{n+1}^{(4)} |$ 相对于步长 $h$ 更加平滑和精确。
- 同样具备 FSAL 特性，计算 $k_7$ 的函数值可以复用于下一步的 $k_1$，使得每个成功步长的平均函数求值次数约为6次。
误差控制策略 (模仿 ode45)：为了使误差控制更具鲁棒性，我们不使用固定的绝对误差，而是结合相对容忍度 (RelTol) 和绝对容忍度 (AbsTol)。对于状态向量 y 的每个分量 y_i，容忍度阈值 Tol_i 定义为：
$$ \text{Tol}_i = \text{RelTol} \times |y_i| + \text{AbsTol} $$
这个策略的优点是：
- 当解的数值很大时，误差控制主要由相对容忍度决定。
- 当解趋近于零时，由绝对容忍度托底，防止步长被无限压缩。
最终，我们计算一个归一化的误差率 err_rate：
$$ \text{err\_rate} = \sqrt{ \frac{1}{N} \sum_{i=1}^{N} \left( \frac{E_{n+1, i}}{\text{Tol}_i} \right)^2 } $$
其中 $E_{n+1, i}$ 是第 $i$ 个分量的误差估计。
步长调整决策：
- 如果 err_rate <= 1.0: 接受当前步。使用更高阶的解 $y_{n+1}^{(5)}$ 更新状态，并计算下一个建议步长 $h_{\text{new}}$。
- 如果 err_rate > 1.0: 拒绝当前步。状态回退，使用一个更小的步长 $h_{\text{new}}$ 重新计算。
步长调整的经典公式为：
$$ h_{\text{new}} = h_{\text{old}} \times \text{safe} \times \left( \frac{1.0}{\text{err\_rate}} \right)^{p} $$
- safe: 安全因子，通常取 0.9。
- 指数 p: 对于RK45，通常取 0.2 (即 $1/5$)。

4. SPH右端项（RHS）的计算

在前面的讨论中，我们反复提到函数 $f(t, y)$，它代表了系统状态量的时间导数，即常微分方程的右端项（Right-Hand Side, RHS）。在 SPH 模拟中，这个函数 compute_derivatives 的任务就是根据当前所有粒子的状态，计算出它们各自的时间导数。

对于复杂的物理过程，尤其是涉及固体力学的弹塑性、损伤和断裂时，RHS 的计算远不止一个简单的压力梯度。下面是构成 SPH 中 RHS 的核心部分：

速度导数（加速度 $\mathbf{a}$）: 这是动量方程的右端项。加速度由作用在粒子上的所有力的总和除以质量得到。
$$ \frac{d\mathbf{v}_i}{dt} = \mathbf{a}_i = \frac{1}{m_i} \sum_j \mathbf{F}_{ij} $$
力 $\mathbf{F}_{ij}$ 包括：
- 压力梯度力: 由压强 $P$ 产生。
- 粘性力: 人工粘性，用于处理冲击波。
- 应力散度力: 这是固体力学中的关键项。总应力张量 $\boldsymbol{\sigma}$ 可以分解为各向同性的压力 $P$ 和偏应力张量 $\mathbf{S}$。由偏应力引起的力代表了材料的抗剪切和形变能力。 $$ \boldsymbol{\sigma} = -P\mathbf{I} + \mathbf{S} $$ 因此，加速度的计算需要准确的应力信息。
应力导数（应力率 $\dot{\mathbf{S}}$）: 应力本身不是一个守恒量，它会随着材料的变形而演化。为了计算应力的变化，我们需要本构模型（Constitutive Model）。对于弹塑性材料，通常使用客观应力率（如 Jaumann 率）来描述偏应力张量的时间导数：
$$ \frac{d\mathbf{S}_i}{dt} = \text{JaumannRate}(\mathbf{S}_i, \dot{\boldsymbol{\epsilon}}_i, \boldsymbol{\Omega}_i) $$
其中 $\dot{\boldsymbol{\epsilon}}$ 是应变率张量，$\boldsymbol{\Omega}$ 是自旋张量，均由速度梯度计算得到。
屈服与塑性: 当应力达到材料的**屈服强度（Yield Strength）**时，材料进入塑性流动状态。屈服模型（Yield Model），如 von Mises 或 Drucker-Prager，定义了这个边界。对于岩石等材料，屈服强度还依赖于压力。一旦屈服，就需要通过“径向返回算法”将应力拉回到屈服面上，这个过程是非线性的，并决定了塑性变形的能量耗散。
损伤导数（损伤率 $\dot{D}$）: 为了模拟材料的开裂和失效，我们引入一个内部状态变量——损伤 $D$ (从0到1)。损伤模型（Damage Model），如 Grady-Kipp 模型，描述了损伤如何随着拉伸或应变而累积。
$$ \frac{dD_i}{dt} = g(\boldsymbol{\sigma}_i, \dot{\boldsymbol{\epsilon}}_i, D_i, \dots) $$

总结：在每一个时间积分步中，compute_derivatives 函数的计算流程大致如下：

根据当前密度 $\rho$ 和内能 $u$，通过状态方程计算压力 $P$。
利用屈服模型判断当前应力状态。
通过本构模型计算弹性试探应力，如果屈服则进行塑性修正，得到最终的偏应力 $\mathbf{S}$。
利用损伤模型更新损伤变量 $D$。
最后，将压力 $P$ 和偏应力 $\mathbf{S}$ 代入动量方程，计算出最终的加速度 $\mathbf{a}$。
同时，计算内能变化率 $\dot{u}$、密度变化率 $\dot{\rho}$ 等其他变量的导数。

这些导数共同构成了时间积分器所需要的 RHS 向量。

5. 应用算例简述

在实现复杂的自适应积分器后，用一些已知解或具有守恒律的简单问题进行验证是至关重要的一步。

5.1 太阳系模拟

这是一个经典的 N 体问题。每个行星（粒子）的 RHS 就是其他所有天体对其施加的万有引力之和。

$$ \frac{d\mathbf{v}_i}{dt} = \mathbf{a}_i = \sum_{j \ne i} \frac{G m_j (\mathbf{r}_j - \mathbf{r}_i)}{\| \mathbf{r}_j - \mathbf{r}_i \|^3} $$

验证重点：
- 长期能量守恒和角动量守恒：是衡量积分器好坏的关键指标。
- 轨道精度：能否准确再现行星的椭圆轨道。
自适应步长优势：对于具有高偏心率轨道的天体（如彗星），它在靠近太阳时（速度快，引力变化剧烈）会自动采用小步长，而在远离时（速度慢，引力平缓）则采用大步长，兼顾了精度和效率。

5.2 单摆模拟

一个简单的单摆系统由以下一阶方程组描述：

$$ \begin{cases} \frac{d\theta}{dt} = \omega \\ \frac{d\omega}{dt} = -\frac{g}{L} \sin(\theta) \end{cases} $$

验证重点：
- 周期稳定性：对于小角度摆动，周期应接近 $2\pi\sqrt{L/g}$。
- 能量守恒：在无阻尼情况下，总能量（动能+势能）应保持不变。
自适应步长优势：当摆锤经过最低点（速度最快）时，步长会自然减小；在最高点（速度为零）时，步长会增大。这展示了积分器对系统动态的灵敏响应。

6. 结合SPH的计算伪代码

现在，我们将上述 RK45 误差控制逻辑整合到 SPH 的主循环中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61


// --- 全局参数 ---
double RelTol = 1e-6; // 相对容忍度
double AbsTol = 1e-9; // 绝对容忍度
double h_min = 1e-8, h_max = 1e-2; // 步长上下限
double safe_factor = 0.9;
double max_increase = 5.0, min_decrease = 0.2;

// --- 主循环 ---
double t = 0.0;
double h = initial_dt; // 初始步长
// y_n 包含了所有粒子的位置、速度、内能、应力等状态量
StateVector y_n = get_initial_conditions();

// 预计算下一步的 k1 (利用 FSAL 特性)
RHSVector k1 = compute_derivatives(t, y_n);

while (t < T_max) {
 bool step_accepted = false;

 while (!step_accepted) {
 if (h < h_min) {
 error("Timestep smaller than h_min");
 break;
 }

 // 1. RK45 核心计算：利用已有的 k1 计算 k2, ..., k7
 // 并得到 y_next_4 (四阶解) 和 y_next_5 (五阶解)
 // (此处省略繁杂的系数计算，但会返回 k_next 用于 FSAL)
 auto [y_next_4, y_next_5, k_next] = perform_rk45_step(t, y_n, h, k1);

 // 2. 计算误差率 err_rate (模仿 MATLAB)
 double err_rate = calculate_error_rate(y_n, y_next_4, y_next_5, RelTol, AbsTol);

 // 3. 决策与步长调整
 double h_new = h * safe_factor * pow(err_rate, -0.2);

 if (err_rate <= 1.0) {
 // --- 接受步长 ---
 step_accepted = true;
 t += h;
 y_n = y_next_5; // 更新状态为更高阶的解
 k1 = k_next; // FSAL: 下一步的 k1 已经算好

 // 限制步长增幅
 h = min({h * max_increase, h_new, h_max});

 } else {
 // --- 拒绝步长 ---
 // 状态 y_n, t, k1 保持不变

 // 限制步长降幅
 h = max({h * min_decrease, h_new, h_min});
 }
 }

 // (可选) 在每个成功的时间步后，更新邻域、输出数据等
 UpdateAndSaveData(t);
}

// `compute_derivatives` 函数实现了第4节描述的RHS计算逻辑。
// `perform_rk45_step` 和 `calculate_error_rate` 分别实现了第3节的算法核心和误差控制。