SPH流体模拟系列教程 on Keqi的博客

SPH基础(序): 概述与系列介绍

plloningye@gmail.com (Keqi Ye) — Mon, 20 May 2024 00:00:00 +0000

SPH 系列总览

本系列文章旨在从零开始，系统介绍光滑粒子流体动力学（SPH, Smoothed Particle Hydrodynamics）方法的核心概念、数学原理以及实现技巧。通过本系列，你将能够：

理解 SPH 方法的基本思想和应用场景。
学会选择合适的核函数，并掌握其实现方式。
掌握邻居搜索，常微分方程求解等关键算法。
逐步搭建自己的 SPH 流体模拟框架。

系列结构

本系列主要包含以下内容：

SPH 方法简介
SPH 的基本原理、流体模拟的数学模型和物理背景。
核函数的选择与实现
常用核函数类型及其在数值模拟中的应用。
状态方程
如何建立和应用流体的状态方程，计算压力与密度关系。
邻居搜索与数据结构
高效邻居搜索方法、树结构和邻居列表构建技巧。
高级主题与优化
自适应时间步长、并行计算优化等进阶内容。

阅读本篇文章后，你可以从各个子文章入手，逐步深入理解 SPH 模型和实现细节。本系列适合有一定编程基础和物理背景的读者，但也会从基础讲起，让新手逐步掌握方法。

SPH基础(一): 核函数与导数近似

plloningye@gmail.com (Keqi Ye) — Tue, 21 May 2024 10:00:00 +0800

欢迎来到“SPH 系列教程”系列！

光滑粒子流体动力学（Smoothed Particle Hydrodynamics, SPH）是一种无网格的拉格朗日粒子法。与传统的基于网格的方法不同，SPH 通过一系列离散的粒子来代表连续的流体，极大地简化了对大变形、自由表面等问题的处理。

本系列的第一篇文章，我们将从 SPH 的两个最核心的概念——核函数近似与导数近似——开始。

什么是核函数近似？

在 SPH 中，任何一个连续场 $A$ 在空间任意一点 $\mathbf{r}$ 的值，都可以通过一个对邻近粒子的加权求和来近似：

$$ A(\mathbf{r}_i) \approx \sum_{j} A(\mathbf{r}_j) W(\mathbf{r}_i - \mathbf{r}_j, h) V_j $$

这里的：

$A(\mathbf{r}_i)$ 是我们想要求的粒子 $i$ 的场量值。
求和遍历粒子 $i$ 的所有邻居粒子 $j$。
$W$ 是核函数，一个根据距离分配权重的函数。
$h$ 是光滑长度，定义了核函数的影响范围。
$V_j$ 是粒子 $j$ 的体积，通常等于其质量除以密度 ($V_j = m_j / \rho_j$)。

这个公式的核心思想是：一个点的属性，可以由其周围点的属性加权平均得到。

如何近似一个场的导数？

SPH 的真正威力在于它也能方便地近似一个场的导数（如梯度、散度），这是构建物理控制方程（如流体力学的纳维-斯托克斯方程）的关键。场 $A$ 在粒子 $i$ 处的梯度 $\nabla A(\mathbf{r}_i)$ 可以通过以下对称形式来近似：

$$ \nabla A(\mathbf{r}_i) \approx \sum_{j} [A(\mathbf{r}_j) - A(\mathbf{r}_i)] \nabla_i W(\mathbf{r}_i - \mathbf{r}_j, h) V_j $$

其中 $\nabla_i W$ 是核函数对粒子 $i$ 坐标的梯度。这个形式具有良好的数值稳定性，并且保证了一个常数场的梯度为零。

与有限元法（FEM）的类比: 如果读者对有限元法有了解，会发现这两种方法在哲学上是相通的。无论是SPH还是FEM，它们都巧妙地将对未知场函数的微分操作，转移到了已知的、解析的基函数（SPH中的核函数，FEM中的形函数）上。这样做最大的好处是避免了对离散数据点进行直接的数值差分，因为后一种方法对粒子/节点的无序性和噪声非常敏感，容易导致数值不稳定和精度损失。

常用核函数及其梯度

一个好的核函数需要满足归一性、紧支撑性等性质。下面介绍几种在 SPH 中常用的核函数。

注意：以下公式中的归一化常数 $\alpha$ 均是三维空间下的值。在不同维度下，这些常数会发生变化。

1. 三次样条核 (Cubic Spline Kernel)

这是SPH中最经典和广泛使用的核函数之一，因其良好的稳定性和近似二阶高斯函数的特性而备受青睐。

其数学表达式为：

$$ W(R,h) = \alpha_d \times \begin{cases} \frac{2}{3} - R^2 + \frac{1}{2}R^3, & 0 \le R < 1; \\ \frac{1}{6}(2-R)^3, & 1 \le R < 2; \\ 0, & R \ge 2. \end{cases} $$

其中，归一化常数 $\alpha_d$ 在不同维度下分别为：

一维: $\alpha_d = \frac{1}{h}$
二维: $\alpha_d = \frac{15}{7\pi h^2}$
三维: $\alpha_d = \frac{3}{2\pi h^3}$

2. 二次光滑核 (Quadratic Kernel for Impact Problems)

根据Johnson等人 (1996b) 的研究，在模拟高速冲击问题时，可以采用以下的二次光滑函数。

其数学表达式为：

$$ W(R,h) = \alpha_d \left(\frac{3}{16}R^2 - \frac{3}{4}R + \frac{3}{4}\right), \quad 0 \le R \le 2. $$

其中，归一化常数 $\alpha_d$ 在不同维度下分别为：

一维: $\alpha_d = \frac{1}{h}$
二维: $\alpha_d = \frac{2}{\pi h^2}$
三维: $\alpha_d = \frac{5}{4\pi h^3}$

Matlab 实验：一维函数与导数近似

让我们通过一个更全面的 Matlab 实验来感受这些概念。下面的代码将：

在一个一维域上近似函数 $y = \sin(x)$ 及其导数 $y’ = \cos(x)$。
提供多种核函数（cubic, poly6, spiky）供选择。
可视化整个域上的近似结果和误差。

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


% SPH_APPROXIMATION_1D_ADVANCED.m
%
% 描述:
% 这是一个更高级的1D SPH实验，用于近似一个函数及其一阶导数。
% 1. 使用多种核函数（Cubic Spline, Poly6, Spiky）。
% 2. 近似整个函数域，而不仅仅是一个点。
% 3. 可视化函数近似和导数近似的误差。

clear; clc; close all;

%% 1. 参数设置
L = 2 * pi; % 定义域长度 [0, 2*pi]
N = 100; % 粒子数量
dx = L / N; % 粒子间距 (每个粒子的“体积”)

% --- 可调参数 ---
h_factor = 2.0; % 光滑长度因子 h = h_factor * dx
kernel_choice = 'cubic'; % 可选: 'cubic', 'poly6', 'spiky'
% ... (代码其余部分和上面提供的一样)

SPH基础(二): 网格法邻居搜索

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

SPH 粒子领域搜索

问题描述

在光滑粒子流体动力学（Smoothed Particle Hydrodynamics，简称 SPH）方法中，“邻居搜索”（Neighbor Search）是一个至关重要的计算任务。它直接影响到模拟的效率与精度，尤其在涉及上百万粒子的三维问题中，计算瓶颈往往出现在如何高效查找每个粒子周围的邻居上。

由于 SPH 是一种无网格方法，天然适合处理自由表面、大变形和断裂等复杂物理现象，因此被广泛应用于天体物理、流体力学、固体力学等领域。我主要从事小行星撞击问题的数值模拟研究，并开发了一套针对该问题的 SPH 代码。虽然不同领域在实现细节上存在差异，但“邻居搜索”作为核心模块，其数学模型相对简单，却几乎在所有 SPH 实现中都不可或缺。

本文旨在系统介绍 SPH 中邻居搜索的常见算法、性能优化方法，以及在 CUDA 等并行计算平台上的实现，作为我个人学习与研究的记录，同时希望对同领域的研究者提供参考。

首先给出 SPH 粒子邻居搜索的抽象数学问题：设在三维空间中存在 $ N $ 个粒子，每个粒子的位置已知，记为 $ \mathbf{x}_i $，每个粒子有一个核长度（smoothing length）$ h_i $。我们需要找到每个粒子 $ i $ 的邻居粒子集合 $ j $，使得满足以下条件：

\[ \|\mathbf{x}_i - \mathbf{x}_j\| < f(h_i, h_j) \]

其中，函数 $ f(h_i, h_j) $ 用于定义粒子间的交互距离，其常见定义包括：

$ f(h_i, h_j) = \eta \cdot \frac{1}{2}(h_i + h_j) $
$ f(h_i, h_j) = \eta \cdot \min(h_i, h_j) $
$ f(h_i, h_j) = \eta \cdot \max(h_i, h_j) $

这里，$ \eta $ 是一个无量纲系数，称为核支持半径因子（kernel support radius factor），通常取值在 $ [1.2, 2.5] $ 之间，用于控制粒子的影响范围（本文取2）。

在邻居搜索中，常见的方法包括：

暴力搜索（Brute Force）：简单可靠，但时间复杂度高（$O(N^2)$），在大规模问题中效率低下；
链表搜索（Linked-Cell/Grid-based）：通过空间划分显著减少搜索粒子数，是实际中常用的高效方法；
树搜索（如 Octree 或 KD-tree）：适合不均匀粒子分布，尤其适用于天体物理模拟中的自适应精度问题，良好的树代码具有非常高的鲁棒性。如果要考虑自引力，那么树搜索是效率和精度都不错的选择。

本文将以暴力搜索作为结果基线，重点介绍如何高效实现链表搜索和树搜索，并比较它们在实际 SPH 模拟中的性能表现。

1. 链表搜索（Linked-Cell/Grid-based）

在光滑长度为空间常量的情况下，也即所有粒子的$ h_i $都相等，应用链表搜索法非常有效。Monaghan 和 Gingold(1983)提出，可以通过对粒子的空间区域划分网格，记录每个网格内的粒子编号。这样在搜索粒子的邻居时，只需要遍历当前粒子网格的邻居网格内的粒子即可。此方法在传统SPH代码中使用非常多，如Monaghan(1985)，Rhoades(1992)，Simpson(1995)等。

在实现链表算法时，要在问题域上铺设一临时网格。网格单元的空间大小应选取与支持域的空间大小一致。若光滑函数支持域的计量尺度为 $ \eta h $，则网格单元的尺度也必须设置为 $ \eta h $。那么，对于给定的粒子i，其相邻粒子只能在同一网格单元内，或者在紧密相邻的单元内。所以，当 $ \eta = 2 $ 时，在一维、二维和三维空间里的搜索范围分别是在 3,9,27 个单元内。链表搜索法将每个粒子都分布在网格单元内，并通过简单的存储规则将每个网格内的所有粒子连接起来。若每个单元内的平均粒子数量足够小，则链表搜索法的复杂度阶数为 $ O(N) $。

链表搜索法存在的问题是，当光滑长度可变时，尤其是模拟分辨率变化的问题时，网格空间就不能适应每一个粒子，此时若再应用链表搜索法，则搜索效率会很低。除此之外，该方法在CUDA上实现时，需要对显存分配进行小心处理，不然很容易占用超大显存（主要在存储网格粒子编号时）。下面首先就光滑长度为空间常量的情况下进行代码说明。

光滑长度为空间常量的链表搜索

我们先来看链表搜索算法的基础版本。实现该算法需要两个步骤：

记录每个网格单元中包含哪些粒子，并记录每个粒子所属的单元；
遍历所有粒子，对每个粒子的单元及其邻接单元进行扫描，查找可能的邻居粒子。

为了提高效率，本文只展示核函数的编写，且不在每次调用中反复申请或释放内存。

第一个核函数较为简单，其用于构建粒子与网格单元之间的映射关系。

核函数声明与粒子网格索引计算

下面是用于建立粒子与网格单元之间映射关系的 CUDA 核函数 particleLoop，以及配套的粒子网格索引计算函数 particleGridIndex。本版本假设所有粒子的核长度 $h$ 是一个常量，记为 h[0]。

 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


#define DIM 3 // 空间维度：可设为 1, 2 或 3
#define MAX_PARTICLES_PER_GRID 200 // 每个网格单元最多可容纳的粒子数
#define eta 2 // 核长度比例因子

// CUDA 核函数：构建每个粒子所属网格，以及每个网格中的粒子列表
__global__ void particleLoop(
 const double *x, // 粒子 x 坐标，长度为 numParticles
 const double minx, // x 方向最小坐标
 const int nx, // x 方向网格数 = ceil((maxx - minx) / (η * h))
#if DIM > 1
 const double *y, // 粒子 y 坐标
 const double miny,
 const int ny,
#endif
#if DIM > 2 
 const double *z, // 粒子 z 坐标
 const double minz,
 const int nz,
#endif
 const double *h, // 每个粒子的核长度（此版本为常量）
 int *gridParticlesList, // 网格中粒子索引列表，大小为 numGrids * MAX_PARTICLES_PER_GRID 无须初始化
 int *gridWritingPointer, // 为避免数据竞争，使用一个gridWritingPointer来记录写入位置，长度为numGrids，需要初始化为0
 int *particleGridList, // 每个粒子所属网格索引，长度为 numParticles
 int numParticles, // 粒子总数
 int numGrids // 网格总数
) {
 int tid = threadIdx.x + blockIdx.x * blockDim.x;
 if (tid >= numParticles) return;

 // 计算粒子在网格中的索引坐标
 int ix = int((x[tid] - minx) / (h[0])*eta); // η = 2
#if DIM > 1
 int iy = int((y[tid] - miny) / (h[0])*eta);
#else
 int iy = 0;
#endif
#if DIM > 2
 int iz = int((z[tid] - minz) / (h[0])*eta);
#else
 int iz = 0;
#endif

 // 获取粒子所在网格的线性索引
 int gridIndex;
#if DIM == 1
 gridIndex = ix;
#elif DIM == 2
 gridIndex = ix + iy * nx;
#else // DIM == 3
 gridIndex = ix + iy * nx + iz * nx * ny;
#endif
 particleGridList[tid] = gridIndex;

 // 获取当前网格的gridWritingPointer位置
 int writingPointer = atomicAdd(&gridWritingPointer[gridIndex], 1); // atomicAdd返回写入位置
 gridParticlesList[gridIndex * MAX_PARTICLES_PER_GRID + writingPointer] = tid;
}

使用上述函数时要注意，当网格个数很多时，容易超过int的表达范围。此外，前置条件是需要知道最小和最大的粒子坐标，长数组求最大最小值可以使用scan算法，以后有空也会介绍此类算法。

至此，我们已经建立了空间粒子与网格之间的联系，现在可以遍历粒子，获取他们的邻居粒子。我目前想到两种遍历方法，1. 按粒子顺序遍历（下面称A1） 2. 按网格顺序遍历（下面称A1）。

搜索

按粒子顺序遍历(A1)

首先来看第一个遍历方法：按粒子顺序遍历(A1)。事实上

 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
62
63
64


#define MAX_NEIGHBORS 200 // 每个粒子最多的邻居数

__global__ void neighborSearchByParticles(
 const double *x, const double *y, const double *z,
 const double *h,
 const int *gridParticlesList, // 网格中粒子索引
 const int *gridWritingPointer, // 每个网格中的粒子数量（已由atomicAdd更新）
 const int *particleGridList, // 每个粒子所在网格索引
 const double minx, const double miny, const double minz,
 const int nx, const int ny, const int nz,
 int *neighborList, // 输出：每个粒子的邻居列表，大小为 numParticles * MAX_NEIGHBORS
 int *neighborCount, // 输出：每个粒子的邻居数
 int numParticles
) {
 int tid = threadIdx.x + blockIdx.x * blockDim.x;
 if (tid >= numParticles) return;

 double xi = x[tid], yi = y[tid], zi = z[tid];
 double hi = h[0];
 double hi2 = hi * hi;
 int gridIndex = particleGridList[tid];

 // 计算该粒子所在网格的坐标索引
 int ix = gridIndex % nx;
 int iy = (gridIndex / nx) % ny;
 int iz = gridIndex / (nx * ny);

 int count = 0;

 // 遍历该粒子所在网格及其周围 3x3x3 网格
 for (int dx = -1; dx <= 1; ++dx) {
 int nix = ix + dx;
 if (nix < 0 || nix >= nx) continue;
 for (int dy = -1; dy <= 1; ++dy) {
 int niy = iy + dy;
 if (niy < 0 || niy >= ny) continue;
 for (int dz = -1; dz <= 1; ++dz) {
 int niz = iz + dz;
 if (niz < 0 || niz >= nz) continue;

 // 相邻网格索引
 int neighborGrid = nix + niy * nx + niz * nx * ny;
 int npg = gridWritingPointer[neighborGrid];

 for (int k = 0; k < npg; ++k) {
 int j = gridParticlesList[neighborGrid * MAX_PARTICLES_PER_GRID + k];
 if (j == tid) continue;

 double dx = x[j] - xi;
 double dy = y[j] - yi;
 double dz = z[j] - zi;
 double dist2 = dx*dx + dy*dy + dz*dz;

 if (dist2 < hi2 && count < MAX_NEIGHBORS) {
 neighborList[tid * MAX_NEIGHBORS + count] = j;
 count++;
 }
 }
 }
 }
 }

 neighborCount[tid] = count;
}

事实上，particleGridList 数组是专门为 A1 方案 设计的；而若采用 A2 方案，则无需该数组。

A1 的缺点在于：当粒子在数组中呈随机排布时，线程束（warp）之间对粒子属性和网格数据的访问也将是随机的。在 CUDA 编程中，访存模式对性能影响极大，因此可以预期 A1 的效率不会非常理想。

在一个失眠的深夜，我思考了两个问题：

如何优化 A1 的访存模式？
当粒子的核尺度 $ h $ 相差悬殊（例如在模拟月球遭受小行星撞击时，$h_{min} ≈ 1$，$h_{max} ≈ 500$），如何在链表结构中高效支持如此大的跨度？

关于这两个问题，我各自有一些设想和初步实现，接下来将逐一介绍，并进行测试和分析。

A2：按网格顺序遍历粒子

（此处补充 A2 的实现简介和性能特点。）更多关于树搜索的内容可以参见[树搜索]更多关于树搜索的内容可以参见树搜索.

缺陷

网格搜索我个人感觉效率是比树搜索好的，尤其是当粒子的光滑长度都一致或者差不多的时候。缺点在于，如果粒子在空间中分散的非常广泛，比如撞击引起的dust喷发。这会导致网格数量激增，显存很快就会用光，导致计算失败。因此网格搜索还是适合模拟空间分布稳定的问题，比如溃坝。

SPH基础(三): 树结构邻居搜索

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

树结构（基于根据 Burtscher 和 Pingali 的研究）

本文将介绍广泛用于 SPH 代码和 N 体模拟中的树结构（Tree Structure）。这种数据结构主要应用于以下两个核心问题：

1. 粒子领域搜索（Neighbor Search）

在 SPH（光滑粒子流体力学）模拟中，每个粒子需要在核尺度 $ h $ 范围内查找邻居粒子，以便计算密度、压强梯度、粘性等物理量。树结构能够加速邻域搜索，尤其适用于粒子分布高度非均匀的情形。

2. 自引力计算（Self-Gravity Computation）

在引力主导的粒子系统（如星系模拟、星体碰撞）中，粒子间存在万有引力作用。直接计算所有粒子对的引力开销为 $ \mathcal{O}(N^2) $，不可接受。基于树的近似方法（如 Barnes-Hut 算法）可将计算复杂度降至 $ \mathcal{O}(N \log N) $，同时保持较高精度。

接下来的章节将分别介绍树结构在上述两个问题中的构建方法、搜索策略和性能优化。

关于传统的 链表法（Linked-List） 粒子领域搜索，请参考我另一篇博文： 👉 使用链表进行 SPH 邻域搜索

实现步骤

根据相关文献，每次执行自引力计算或粒子邻域搜索时，通常需要以下四个步骤：

确定粒子空间范围
统计所有粒子的空间边界，获取 $ x_{\min}, x_{\max}, y_{\min}, y_{\max}, z_{\min}, z_{\max} $，用于初始化树结构的根节点或空间划分范围。
构建树结构
将粒子递归划分到空间树节点中，常用的数据结构包括八叉树（Octree）或 KD 树。每个叶子节点包含若干粒子或达到最小划分条件。
粒子空间排序
对粒子进行 Morton 编码（Z-order curve）或 Hilbert 曲线编码，并按照空间位置排序，便于缓存一致性和后续并行处理。
树遍历计算
遍历树结构：
- 若执行 自引力计算，使用 Barnes-Hut 近似规则判断是否聚合节点质量；
- 若执行 邻域搜索，在每个节点中判断与查询粒子的距离是否小于核尺度 $ h $，从而筛选可能邻居。

确定粒子空间范围

直接使用规约算法求最大最小值

构建树结构

由于 GPU 上无法高效实现指针式链表结构，我们使用数组来模拟树的链接关系（例如子节点指针）。假设有一个整型数组 child，其长度远大于粒子总数 numParticles，并初始化为 -1，表示所有节点尚未使用。

区分叶子节点与根节点

在树结构中，如何区分整型数组 child 的某一个位置存储的是 叶子节点（粒子） 还是 根节点 是一个关键问题。

标识方法：

-1：表示该位置为空，未被占用。
-2：表示该位置已被锁定，当前线程正在使用该位置（通常用于进行原子操作）。
-3：表示该位置是一个节点，每个节点一定会有子树（可能是子节点，也可能是粒子，粒子的子节点一定为空：-1）。
0 到 numParticles - 1：表示粒子，每个位置对应一个粒子。

显然，如果第 i 个位置被锁定，那么：

在三维情况下，8*i+1+0 到 7（即一个八岔树及其子树等）都被锁定；
在二维情况下，4*i+1+0 到 3（即一个四岔树及其子树等）都被锁定；
在一维情况下，i 及其相邻部分也会被锁定。

注意，任意索引i的子节点计算方法为：8*i+1+0，与传统的八叉树计算方法不同，这是因为我的代码中，0节点保存的是最大的根节点信息。

– 这意味着，如果一个位置被锁定，其他线程将无法访问该位置的子树或其子树的子树，确保了并行计算中节点及其相关子节点的安全。

使用原子操作同步线程

当多个线程并发地尝试访问同一个子节点槽位时，可以使用 CUDA 提供的原子操作 atomicCAS（Compare And Swap）来进行线程间同步。

以下是原子操作的代码示例：

1

int re = atomicCAS(&child[p], -1, -2); // 尝试占用 child[p]

该操作的含义是：

若 child[p] == -1：表示该槽位尚未被占用，当前线程成功将其原子地设置为 -2，表示“锁定中”或“准备插入”；
若 child[p] != -1：说明该槽位已被其他线程占用或已被插入，当前线程需退出或重试；
返回值 re：表示操作前的旧值。如果 re == -1，则说明当前线程成功锁定了该节点。如果 re != -1 ，则 atomicCAS 函数发现比较不成立，直接返回了旧值，也不会替换-2而打乱child数组内容。

写到这里，树结构数组child的构建就很容易了。下面是伪代码

 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
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175


#define childListIndex(nodeIdx, childNum) ((nodeIdx) * TREETYPE + 1 + (childNum))

#define EMPTY -1
#define LOCKED -2
#define TRUE 1
#define FALSE 0
#define NODE -3

//RealType4 是 float4 或 double4 的别名，我这样写是为了区分单双精度计算，众所周知，消费级显卡的双精度计算能力比较差。。
//粒子的w分量存放了质量，节点的w分量存放了节点半径（正方体的边长的一半）。
//目前还没有添加节点质心的计算逻辑，后续会加，用于计算粒子的引力，参考：
//A hierarchical O(N log N) force-calculation algorithm 本文发表在nature上，顶礼膜拜


__global__ void buildTreeKernel(SPHState *deviceP, treeData *tree)
{
 // 为避免混淆，明确区分粒子和节点的位置数组
 RealType4 *particlePositions = deviceP->positions;
 volatile RealType4 *nodePositions = tree->positions;
 RealType4 *nodeRoot = tree->nodeRoot;
 volatile int *childList = tree->childList;
 int childListLength = tree->childListLength;
 int numParticles = tree->numParticles;
 int inc = blockDim.x * gridDim.x;
 int i = threadIdx.x + blockIdx.x * blockDim.x;
 int k;
 int childIndex, child;
 int lockedIndex;
 RealType x, y, z;
 RealType rootRadius = nodeRoot->w;
 RealType rootX = nodeRoot->x;
 RealType rootY = nodeRoot->y;
 RealType rootZ = nodeRoot->z;

 // 添加跟踪当前节点位置的变量
 RealType currentX, currentY, currentZ, currentR;

 int depth = 0;
 int isNewParticle = TRUE;
 int currentNodeIndex;
 bool isInsert;

 while (i < numParticles)
 {
 isInsert = false;
 while (!isInsert)
 {
 RealType4 pos = particlePositions[i];
 depth = 0;
 x = pos.x;
 y = pos.y;
 z = pos.z;

 // 开始于根节点（索引0）
 currentNodeIndex = 0;
 currentX = rootX;
 currentY = rootY;
 currentZ = rootZ;
 currentR = rootRadius;

 childIndex = 0;
 if (x > currentX)
 childIndex = 1;
 if (y > currentY)
 childIndex += 2;
 if (z > currentZ)
 childIndex += 4;

 // 跟随路径到叶节点
 currentNodeIndex = childListIndex(currentNodeIndex, childIndex);
 currentR *= 0.5;
 currentX += ((childIndex & 1) ? currentR : -currentR);
 currentY += ((childIndex & 2) ? currentR : -currentR);
 currentZ += ((childIndex & 4) ? currentR : -currentR);
 child = childList[currentNodeIndex];
 depth++;
 //下面这个while循环是为了寻找叶子节点
 while (child == NODE)
 {
 // 确定在新节点中的子节点索引
 childIndex = 0;
 if (x > currentX)
 childIndex = 1;
 if (y > currentY)
 childIndex += 2;
 if (z > currentZ)
 childIndex += 4;

 // 跟随路径到叶节点
 currentNodeIndex = childListIndex(currentNodeIndex, childIndex);
 currentR *= 0.5;
 currentX += ((childIndex & 1) ? currentR : -currentR);
 currentY += ((childIndex & 2) ? currentR : -currentR);
 currentZ += ((childIndex & 4) ? currentR : -currentR);
 child = childList[currentNodeIndex];
 depth++;
 }

 // 插入粒子到当前节点的子节点
 //三种情况：
 //1.当前叶子节点被占用，那么重试
 //2.当前叶子节点为空，这是最简单的情况，直接插入即可
 //3.当前叶子节点被粒子占用，本线程读取old节点信息，对他们两个节点进行细分，直到他们被分属到不同的象限
 if (child != LOCKED)
 {
 lockedIndex = currentNodeIndex;
 if (child == atomicCAS((int *)&childList[lockedIndex], child, LOCKED))
 {
 if (child == EMPTY)
 {
 // 直接插入粒子
 childList[lockedIndex] = i;
 isInsert = true;
 }
 else
 {
 //此处处理两个节点细分的情形
 。。。。。。
 //这个循环尝试细分，直到他们俩被分开到不同的象限
 do
 {
 // 确定已存在粒子在新节点中的位置
 int childNewIndex = 0;
 if (oldParPos.x > currentX)
 childNewIndex = 1;
 if (oldParPos.y > currentY)
 childNewIndex += 2;
 if (oldParPos.z > currentZ)
 childNewIndex += 4;

 // 确定当前粒子在新节点中的位置
 int currentNewIndex = 0;
 if (x > currentX)
 currentNewIndex = 1;
 if (y > currentY)
 currentNewIndex += 2;
 if (z > currentZ)
 currentNewIndex += 4;

 if (childNewIndex != currentNewIndex)
 {
 // 两个粒子在不同子节点，可以插入
 childList[childListIndex(currentNodeIndex, childNewIndex)] = child;
 childList[childListIndex(currentNodeIndex, currentNewIndex)] = i;
 isInsert = true;
 break; // 退出循环
 }
 else
 {
 // 仍在同一子节点，需要继续细分
 // 注意每次细分都会创建新节点，需要保存节点的包围盒信息 用于领域搜索
 // // 写入新节点的中心和半径
 nodePositions[currentNodeIndex].x = currentX;
 nodePositions[currentNodeIndex].y = currentY;
 nodePositions[currentNodeIndex].z = currentZ;
 nodePositions[currentNodeIndex].w = currentR;
 childList[currentNodeIndex] = NODE;
 // 内存同步，保证所有线程都可以看到有新的节点被写入了
 __threadfence();
 }

 } while (true);

 // 确保所有子树的写入完成
 __threadfence();
 //释放锁
 childList[lockedIndex] = NODE;
 }

 i += inc;
 }
 }
 }
 }
}

当前实现的局限性

虽然稀疏树在数据结构上直观且灵活，但在并行构建和 GPU 加速场景下，它仍然存在一些明显的局限：

节点访问不连续：稀疏树的节点在内存中通常分散存放，导致 GPU 在并行访问时频繁出现非连续内存读取，影响带宽利用率。
显存需求高：由于稀疏树存储方式不连续，GPU 在构建和查询过程中需要额外的显存来管理指针和节点结构，这使得在大规模数据下显存压力大，很容易超过显存限制。

为了解决这些问题，我们提出了 稠密存储的并行树构建方案。该方案将树节点连续存储在内存中，并结合优化的并行算法，使 GPU 能够高效地访问数据，从而显著提升构建速度和查询性能。同时，稠密存储方案能够更合理地利用显存，降低显存占用，提高处理大规模数据的能力。

更多关于实现细节和性能优化的方法，可以参考：基于稠密存储的并行树构建。

[1] Burtscher, Martin, and Keshav Pingali. “An efficient CUDA implementation of the tree-based barnes hut n-body algorithm.” GPU computing Gems Emerald edition. Morgan Kaufmann, 2011. 75-92.

title: 基于稠密存储的并行树构建实现方案 description: date: 2025-08-15 slug: dense-tree-build categories: - 并行计算 - 树结构 - CUDA draft: false

基于稠密存储的并行树构建实现方案

引言

在空间划分与邻域搜索等算法中，树形数据结构（如八叉树、四叉树、Barnes-Hut 树）是高效的加速手段。
构建这类树结构时，存储方式是影响性能与内存效率的关键因素之一。
常见的存储方式有两种：

稀疏存储（Sparse Storage）：为每个节点预留较大索引空间，按需填充，易实现，但会浪费内存。
稠密存储（Dense Storage）：节点存储在连续数组中，按照构建顺序紧密排列，节省内存，但需要额外的管理逻辑。

你之前的实现采用了稀疏存储，在高粒子数时内存占用明显增加。
本文将介绍如何基于稠密存储实现高效的树构建，并给出 CUDA 并行版本的实现思路。

稠密存储的基本思想

稠密存储的目标是：

节点数组紧凑存放，不留大块未使用空间
节点索引直接映射到数组下标
在插入新节点时，通过一个全局 maxNodeIndex 递减分配新位置

这种方法类似“倒着分配”节点空间：

1

[粒子0] [粒子1] ... [粒子N-1] [内部节点M] [内部节点M-1] ...

其中：

0 ~ numParticles-1 区间存放叶子节点（粒子）
numParticles ~ maxNodeIndex-1 区间存放内部节点

数据结构设计

在稠密存储中，核心数据结构通常包括：

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


// 粒子数据
struct Particles {
 double *x, *y, *z; // 坐标
 double *m; // 质量
 double *ax, *ay, *az; // 加速度
 int *depth; // 树深度
};

// 树节点信息
struct Tree {
 volatile double *x, *y, *z; // 节点中心
 volatile double *m; // 节点半径（或质量等）
 int *childList; // 存储子节点索引
 int maxNodeIndex; // 当前可分配的最大索引（递减）
};

关键点：childList 是一维数组，通过 childListIndex(nodeIndex, childSlot) 映射到节点的第几个子节点位置。这样存储方式天然紧凑。

构建流程详解

稠密存储的构建逻辑如下：

初始化根节点
- 根节点索引为 numNodes-1（数组末尾）
- 保存中心坐标和半径
遍历粒子（并行）
- 每个线程处理多个粒子，步长为 blockDim.x * gridDim.x
- 缓存粒子坐标，加速比较
下行查找插入位置
- 从根节点开始，判断粒子属于哪个子象限（八叉树中 0~7）
- 如果子节点是内部节点，继续下行
- 如果子节点是空的，直接插入粒子
- 如果子节点是另一个粒子，创建新的内部节点
创建新内部节点
- 使用 atomicSub 从 maxNodeIndex 分配新的节点索引
- 计算新节点的中心和半径
- 将已有粒子与新粒子分别插入到不同的子槽中
- 如果两者仍落在同一个槽内，继续细分
解锁与同步
- 通过 atomicCAS 实现插入位置的原子锁定
- 使用 __threadfence() 确保内存可见性

核心代码片段

下面是简化版的稠密存储节点分配逻辑：

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


if (child == atomicCAS(&childList[lockedIndex], child, LOCKED)) {
 if (child == EMPTY) {
 childList[lockedIndex] = particleIndex;
 } else {
 // 分配新节点
 newNodeIndex = atomicSub(&maxNodeIndex, 1) - 1;
 // 设置新节点中心与半径
 px[newNodeIndex] = currentX - r + dx;
 py[newNodeIndex] = currentY - r + dy;
 pz[newNodeIndex] = currentZ - r + dz;
 pm[newNodeIndex] = r * 0.5;
 // 初始化子节点
 for (int k = 0; k < numChildren; k++) {
 childList[childListIndex(newNodeIndex, k)] = EMPTY;
 }
 // 将旧粒子和新粒子分别放入不同槽
 childList[childListIndex(newNodeIndex, oldChildSlot)] = oldParticle;
 childList[childListIndex(newNodeIndex, newChildSlot)] = newParticle;
 __threadfence();
 childList[lockedIndex] = newNodeIndex;
 }
}

并发与同步

由于多线程同时构建树，必须保证以下两点：

原子操作
- atomicCAS（Compare And Swap）防止多个线程同时插入同一位置
- atomicSub 分配新节点索引
内存同步
- __threadfence() 确保其他线程能看到已更新的节点数据

注意：稠密存储的节点数组在分配时是倒着使用的，所以不会和粒子索引冲突。

性能分析与优化建议

优点：

内存占用大幅减少（只存实际存在的节点）
索引紧凑，缓存命中率高
遍历效率提升

缺点：

节点分配依赖 atomicSub，在极高并发下可能成为瓶颈
实现复杂度高于稀疏存储

优化方向：

批量分配节点索引，减少 atomicSub 次数
合并锁与节点写入步骤，减少原子操作冲突
在共享内存中缓存部分子节点

总结与应用场景

稠密存储特别适合：

粒子数量大、空间分布均匀的模拟（如 SPH、N-body）
对内存占用敏感的 GPU 应用
需要频繁重建树结构的实时计算

与稀疏存储相比，稠密存储在 GPU 环境下通常能获得更高的性能与更低的内存消耗，尤其是在节点数量接近粒子数量时优势明显。

参考实现：本文的构建思路源自 CUDA 并行 Barnes-Hut 树构建的常见模式，并结合了你的原始代码进行稠密化处理。

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节的算法核心和误差控制。