Ionizing Radiation

About

Tue, 13 Apr 2021 00:00:00 +0800

A Ph.D candidate who majors in physical chemistry.

Abilities	Level¹
C/C++	Beginner
Rust	Beginner
LaTeX	Newbie
VASP	Beginner
Linux	Beginner

https://english.stackexchange.com/questions/83832/list-of-expertise-levels-from-beginner-to-expert ↩︎

External-link

Fri, 16 Apr 2021 21:26:00 +0800

Person	Link
Liam0205	https://liam.page/about/
Mr. Joker	https://mrjokersince1997.gitee.io

单层 TMD 材料的三能带紧束缚模型构建

Tue, 03 Feb 2026 16:59:00 +0800

本文将从对称性与轨道选择出发，逐步构建单层 TMD 的三能带紧束缚模型，并说明它为何足以描述 K/K′ 点附近的带边性质。

引言

单层过渡金属二硫化物（TMD，如 MoS₂、WS₂、MoSe₂ 等）是近年来非常受关注的一类二维半导体材料。它们在单层极限下表现为直接带隙体系，并且具有明显的自旋-轨道耦合效应和能谷（valley）自由度，这使得许多新奇的物理都集中在 K/K' 点附近。在这个能量区间内，价带顶与导带底几乎完全由过渡金属原子的 \(d\) 轨道组成，它们分别是 \(d_{z^2}\) 、 \(d_{xy}\) 与 \(d_{x^2-y^2}\) 。基于这一事实，我们可以构建一个仅包含这三个轨道的紧束缚模型，也就是常常提到的三能带模型。尽管这个模型的基组很小，但已经足够描述 K/K' 点附近的带边性质。

不妨在这里简要介绍一下紧束缚模型。所谓紧束缚模型，是指利用局域的原子轨道来描述晶体电子结构的办法：它假设电子主要局域在各个原子附近，即波函数由一组正交的原子轨道线性组合而成，并允许电子通过有限距离的跳跃 (hopping) 在晶格中传播。它的 Hamiltonian 通常由原位 (on-site) 能级和近邻/远近邻跳跃项组成，它的参数可以由对称性约束得到简化，并通过拟合 DFT 能带得到。紧束缚模型因其形式直观、计算高效，特别适合分析带边、能谷以及自旋-轨道耦合等物理性质。

本文将从对称性出发，依次介绍三能带紧束缚模型基组的选择与 Hamiltonian 的构建，并利用该模型复现 DFT 能带的结果。

TMD 的晶体结构与对称性分析

在构建紧束缚模型之前，我们首先要弄明白研究对象的晶体结构，这包含了材料的晶胞形状以及对称性信息。而紧束缚模型中跳跃矩阵的各项参数并非完全独立，受材料对称性的约束，这些参数之间有存在相应的关联，这些关联操作可以大大减少跳跃矩阵中独立参数的数量，使问题简单化。因此，我们有必要弄明白 TMD 材料的对称性信息。

注：为了避免误会，接下来我们所提到的 TMD 材料均为单层材料。而 TMD 的单层材料中有两个常见的相，分别是 1T 相和 2H 相，其中 1T 相为金属， 2H 相为半导体（或绝缘体）。我们下面所讨论的相均为 2H 相。

TMD 的实空间结构与布里渊区

单层 TMD 材料的化学式为 MX₂ ，其中 M 为过渡金属元素（如Mo、W和V等），X为硫族元素（如S、Se以及Te等）。其结构如图1 所示（图片引自文献¹），图中灰色原子为过渡金属原子，黄色原子为硫族原子，它们组成了一种类似 “三明治”的结构，金属原子形成了二维的六角晶格，硫族原子分别位于金属原子的上下两侧，形成了三棱柱形的配位环境，形状如图1 (b)所示。

Figure 1: TMD 材料的晶体结构以及布里渊区示意图，灰色球为 M 原子，黄色球为 X 原子，(c) 为布里渊区示意图，图片引自文献。

而由于 MX₂ 的原胞为六角晶型，它的布里渊区同样为六角形，如图1 (c)所示。在这个布里渊区中，除了原点 \(\Gamma\) 和边中心 \(M\) 以外，我们对位于六边形顶点的 \(+K\) 与 \(-K\) 点比较感兴趣，它们决定着能谷（valley）中存在许多有趣的物理性质。

TMD 的对称性

单层 TMD 的点群为 \(D_{3h}\) ，它主要包括以下几种对称性：

三重旋转对称性：绕 \(z\) 轴旋转 120° 后系统保持不变，即

\begin{equation} \label{eq:symmetry-C3-xy} C_3: \begin{bmatrix} x \\ y \end{bmatrix} \to \begin{bmatrix} \cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta) \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix}, \;\; \theta = \frac{2\pi}{3} \end{equation}
水平镜面反射：关于 \(xy\) 平面反射后系统不变，即

\begin{equation} \sigma_h: (x, y, z) \to (x, y, -z) \end{equation}
竖直的镜面对称：分别沿 M‒X 键做反映（以1 中沿\(yz\)反映面为例）

\begin{equation} \sigma_v: (x, y, z) \to (-x, y, z) \end{equation}

以上三种对称操作可以相互组合，并形成更多的对称操作，下面将部分操作总结在表1 中

Table 1: TMD 材料的部分对称性操作

对称操作	符号	表达式
旋转 \(\frac{2\pi}{3}\)	\(C_3\)	\(C_3\)
旋转 \(\frac{4\pi}{3}\)	\(C_3^2\)	\(C_3 \cdot C_3\)
沿 \(yz\) 面反映	\(\sigma_v\)	\(\sigma_v\)
沿 \(yz\) 面反映后旋转 \(\frac{2\pi}{3}\)	\(\sigma_v'\)	\(C_3 \cdot \sigma_v\)
沿 \(yz\) 面反映后旋转 \(\frac{4\pi}{3}\)	\(\sigma_v''\)	\(C_3 \cdot C_3 \cdot \sigma_v \)

基组的确定及对称性算符

在构建紧束缚 Hamiltonian 之前，我们需要明确系统的基组。众所周知，“紧束缚模型”也称为“原子轨道线性组合法”（LCAO, linear combination of atomic orbitals），它使用原子轨道作为基组表示系统的波函数，因此我们需要明确具体使用哪些原子轨道。

以 MoS₂ 为例，G. B. Liu¹等使用 DFT 软件计算得到它的原子轨道投影能带，如图2 所示（图片引自文献¹）。不难看出 MoS₂ 的价带最高（VBM）与导带最低（CBM）均主要由原子的 \(d\) 轨道贡献，而 \(p\) 轨道占比相比之下就小很多，\(s\) 轨道则更是几乎没有。由于我们通常只关心 VBM 与 CBM 的带隙与色散，因此只使用 M 原子的这三个 \(d\) 轨道来构成紧束缚模型的基组是可行的。为此我们认为 X 原子的所有轨道以及 M 原子的 \(sp\) 轨道都可以忽略不计，它们不参与紧束缚模型的构建。

Figure 2: 使用 VASP 计算得到的 MoS₂ 能带及原子轨道投影，图片引自文献。

在此，我们的紧束缚模型基组确定为 M 原子的三条 \(d\) 轨道：

\begin{equation} \qty{ \ket{d_{z^2}}, \ket{d_{xy}}, \ket{d_{x^2-y^2}} } \end{equation}

从轨道的基函数表达式不难判断，它们对应了几种对称性：

\(\ket{d_{z^2}}\) 的基函数为 \(z^2\) ，与 xy 无关，因此它对于 \(xy\) 平面内的操作不变，即 \(C_3\) 操作与 \(\sigma_v\) 操作对它不起作用：

\begin{equation} C_3: \ket{d_{z^2}} \to \ket{d_{z^2}}; \;\; \sigma_v: \ket{d_{z^2}} \to \ket{d_{z^2}} \end{equation}
\(\ket{d_{xy}}\) 的基函数为 \(xy\) ，它对于沿 \(yz\) 平面的反映产生符号改变：

\begin{equation} \sigma_v: \ket{d_{xy}} \to - \ket{d_{xy}} \end{equation}
\(\ket{d_{xy}}\) 与 \(\ket{d_{x^2-y^2}}\) 组合起来时，它对三重旋转操作有以下关系

\begin{equation} C_3: \begin{bmatrix} \ket{d_{xy}} \\ \ket{d_{x^2-y^2}} \end{bmatrix} \to \begin{bmatrix} \cos(2\frac{2\pi}{3}) & -\sin(2\frac{2\pi}{3}) \\
\sin(2\frac{2\pi}{3}) & \cos(2\frac{2\pi}{3}) \end{bmatrix} \begin{bmatrix} \ket{d_{xy}} \\ \ket{d_{x^2-y^2}} \end{bmatrix} \end{equation}

这个式子的意思是，当一个波函数可以用 \(\ket{d_{xy}}\) 与 \(\ket{d_{x^2-y^2}}\) 这两种轨道的线性组合表示时，它经过三重旋转后的结果仍可以使用这两个轨道表示，旋转操作只改变了两种轨道的组合系数²。需要指出的是，尽管这个式子看起来与公式\eqref{eq:symmetry-C3-xy} 很像，但它们是完全不同的概念。当前对称操作作用的基底是原子轨道³，而 \eqref{eq:symmetry-C3-xy} 作用的基底则是位置坐标 \(xy\) 。

那么，在 \(\qty{ \ket{d_{z^2}}, \ket{d_{xy}}, \ket{d_{x^2-y^2}} }\) 基组中，上面两种对称操作可以用下面的算符表示：

\begin{equation} \label{eq:Dnmatrix} D(C_3) = \begin{bmatrix} 1 & 0 & 0 \\
0 & \cos(2\frac{2\pi}{3}) & -\sin(2\frac{2\pi}{3}) \\
0 & \sin(2\frac{2\pi}{3}) & \cos(2\frac{2\pi}{3}) \end{bmatrix}; \;\; D(\sigma_v) = \begin{bmatrix} 1 & 0 & 0 \\
0 & -1 & 0 \\
0 & 0 & 1 \end{bmatrix} \end{equation}

有了以上两种对称操作后，表1 中对称操作对应的矩阵形式就都可以得到了。

由于 X 原子不参与到模型中，系统只由 M 原子组成，并且所有 M 原子都在同一平面内，\(z\) 方向上的对称操作对这个系统的基函数也不起作用，因此 \(D_{3h}\) 点群中其它与 \(z\) 方向相关的操作，如 \(xy\) 平面反映 \(\sigma_h\) 与绕 \(x\) 轴的二次旋转 \(C_2\) 等均不需要考虑⁴。

紧束缚 Hamiltonian 的构建

坐标系与近邻原子

在此我们不妨明确一下系统的坐标系，如图3 所示。

Figure 3: 本文所使用的坐标系，以及 M 原子的最近邻（nearest neighbor, NN）、次近邻（next-nearest neighbor, NNN）和第三近邻（third-nearest neighbor, TNN） M 原子位置示意图

图中 \(ab\) 表示两个晶格矢量，它们分别是

\begin{equation} \vec{a} = (l, 0);\;\; \vec{b} = (\frac{l}{2}, \frac{\sqrt{3}}{2}l) \end{equation}

\(l\) 是相邻两个 M 原子的距离，在本文中它也表示晶格常数。最近邻原子、次近邻原子与第三近邻原子的位置分别用 \(R_n\) 、 \(\tilde{R}_n\) 以及 \(2R_n\) (\(n = 1, 2, …, 6\)) 表示，它们对应的分数坐标为

\begin{gathered} R_1 = (1, 0);\; R_2 = (0, 1);\; R_3 = (-1, 1);\\
R_4 = (-1, 0);\; R_5 = (0, -1);\; R_6 = (1, -1) \\
\\
\tilde{R}_1 = (1, 1);\; \tilde{R}_2 = (-1, 2);\; \tilde{R}_3 = (-2, 1);\\
\tilde{R}_4 = (-1, -1);\; \tilde{R}_5 = (1, -2);\; \tilde{R}_6 = (2, -1) \\
\\
2R_1 = (2, 0);\; 2R_2 = (0, 2);\; 2R_3 = (-2, 2);\\
2R_4 = (-2, 0);\; 2R_5 = (0, -2);\; 2R_6 = (2, -2) \\
\end{gathered}

紧束缚模型 Hamiltonian

由于我们研究的晶胞内只包含一个 M 原子，每个原子有三个 \(d\) 轨道，因此三能带模型的紧束缚 Hamiltonian 在动量空间中表示为一个 3x3 的矩阵

\begin{equation} \label{eq:tb-hamiltonian} H(\vb{k}) = \begin{bmatrix} H_{11}(\vb{k}) & H_{12}(\vb{k}) & H_{13}(\vb{k}) \\
H_{21}(\vb{k}) & H_{22}(\vb{k}) & H_{23}(\vb{k}) \\
H_{31}(\vb{k}) & H_{32}(\vb{k}) & H_{33}(\vb{k}) \end{bmatrix} \end{equation}

为了方便起见，我们不妨定义以下记号

\begin{equation} \ket{\phi_1} = d_{z^2}\, , \; \ket{\phi_2} = d_{xy}\, , \; \ket{\phi_3} = d_{x^2-y^2} \end{equation}

公式 \eqref{eq:tb-hamiltonian} 中每一项对应的表达式为

\begin{equation} \label{eq:tb-hamiltonian-Hijk} H_{ij}(\vb{k}) = \sum_{\vb{R}} e^{i\vb{k}\vdot\vb{R}} E_{ij}(\vb{R}) \end{equation}

其中 \(E_{ij}(\vb{R})\) 即为轨道间的跳跃项，

\begin{equation} \label{eq:on-site} E_{ij}(\vb{R}) = \mel{\phi_i(\vb{r})}{\hat{H}}{\phi_j(\vb{r} - \vb{R})} \end{equation}

它表示位于原点的 \(i\) 轨道跳跃到位于 \(\vb{R}\) 的 \(j\) 轨道的能量积分，这里 \(\vb{R}\) 表示近邻的原子。这个积分有一个十分重要的性质 \(E_{ij}( R) = E_{ji}(-R)^*\) ，证明如下

\begin{equation} \label{eq:tb-hopping-transpose} \begin{aligned} E_{ij}(\vb{R}) &={} \mel{\phi_i(\vb{r})}{\hat{H}}{\phi_j(\vb{r} - \vb{R})} \\
&={} \mel{\phi_j(\vb{r} - R)}{\hat{H}}{\phi_i(\vb{r})}^* \\
&={} \mel{\phi_j(\vb{r})}{\hat{H}}{\phi_i(\vb{r} + \vb{R})}^* \quad (\text{变量替换} \vb{r} \to \vb{r} + \vb{R}) \\
&={} E_{ji}(-\vb{R})^* \\
\end{aligned} \end{equation}

此外，当有了其中一个近邻原子轨道的 \(E_{ij}(\vb{R})\) 后，我们可以通过对称性操作推导出其它近邻原子轨道对应的跳跃积分 \(E_{ij}(\vb{R'})\)，它们可以通过下面的式子推得

\begin{equation} \label{eq:tb-hopping-symmetry} E(\hat{g}_n \vb{R}) = D(\hat{g}_n) E(\vb{R}) \bqty{D(\hat{g}_n)}^{\dagger} \end{equation}

\(E( R)\) 表示由 \(E_{ij}(\vb{R})\) 组成的矩阵， \(\hat{g}_n\) 是具体的对称操作， \(D(\hat{g}_n)\) 是 \(\hat{g}_n\) 对应的矩阵形式，它们已在公式\eqref{eq:Dnmatrix} 中给出⁵。

在 TMD 中，根据考虑近邻原子的多少不同，跳跃项分最近邻项、次近邻项和第三近邻项，下面将以最近邻模型和第三近邻模型为例分别阐述它们的具体形式。

参数	文献符号	数值 (eV)	参数	文献符号	数值 (eV)
\(\epsilon_1\)	\(\epsilon_1\)	1.046	\(t_{13}\)	\(t_2\)	0.507
\(\epsilon_2\)	\(\epsilon_2\)	2.104	\(t_{22}\)	\(t_{11}\)	0.218
\(t_{11}\)	\(t_0\)	-0.184	\(t_{23}\)	\(t_{12}\)	0.338
\(t_{12}\)	\(t_1\)	0.401	\(t_{33}\)	\(t_{22}\)	0.057

r11, r12, r13 = sym.symbols("r11, r12, r13", real=True)
r21, r22, r23 = sym.symbols("r21, r22, r23", real=True)
r31, r32, r33 = sym.symbols("r31, r32, r33", real=True)

DC3 = sym.Matrix([[1,          0,         0],
                  [0,    -S(1)/2, sqrt(3)/2],
                  [0, -sqrt(3)/2,   -S(1)/2]])

DSigmaV = sym.Matrix([[1,  0, 0],
                      [0, -1, 0],
                      [0,  0, 1]])

r = sym.Matrix([[r11, r12, r13],
                [r21, r22, r23],
                [r31, r32, r33]])

equation_matrix = (DSigmaV * DC3) * r * (DSigmaV * DC3).T - r
equations = list(equation_matrix)
solutions = sym.solve(equations, (r11, r12, r13, r21, r22, r23, r31, r32, r33))
print(solutions)

# Output:
# {r12: -sqrt(3)*r13, r21: -sqrt(3)*r31, r22: -2*sqrt(3)*r32/3 + r33, r23: r32}

因此可得简化后的跳跃矩阵

\begin{equation} E(\tilde{R}_1) = \begin{bmatrix} r_{11} & r_{12} & -\frac{1}{\sqrt{3}} r_{12}\\
r_{21} & r_{22} & r_{23} \\
-\frac{1}{\sqrt{3}} r_{21} & r_{23} & r_{22} + \frac{2}{\sqrt{3}} r_{23} \end{bmatrix} \end{equation}

有了 \(\tilde{R}_1\) 后，我们可以通过对称性陆续得到其它的次近邻跳跃项 \(\tilde{R}_2 \cdots \tilde{R}_6\)

为方便理解，我们先从 \(\tilde{R}_4\) 开始，刚好有 \(\tilde{R}_4 = -\tilde{R}_1\) ，因此有

\begin{equation} E(\tilde{R}_4) = E(\tilde{R}_1)^{\dagger} \end{equation}
\(\tilde{R}_2\) 可以使用 \(\tilde{R}_4\) 经过两次 \(C_3\) 转动得到

\begin{equation} E(\tilde{R}_2) = D(C_3 \cdot C_3) E(\tilde{R}_1)^{\dagger} D(C_3 \cdot C_3)^{\dagger} \end{equation}
\(\tilde{R}_3\) 可以使用 \(\tilde{R}_1\) 经过一次 \(C_3\) 转动得到

\begin{equation} E(\tilde{R}_3) = D(C_3) E(\tilde{R}_1) D(C_3)^{\dagger} \end{equation}
\(\tilde{R}_5\) 可以使用 \(\tilde{R}_1\) 经过两次 \(C_3\) 转动得到

\begin{equation} E(\tilde{R}_5) = D(C_3 \cdot C_3) E(\tilde{R}_1) D(C_3 \cdot C_3)^{\dagger} \end{equation}
\(\tilde{R}_6\) 可以使用 \(\tilde{R}_4\) 经过一次 \(C_3\) 转动得到

\begin{equation} E(\tilde{R}_6) = D(C_3) E(\tilde{R}_1)^{\dagger} D(C_3)^{\dagger} \end{equation}

此时次近邻跳跃的 Hamiltonian 形式如下：

\begin{aligned} H^{\text{NNN}} &={} e^{i\vb{k}\cdot \vb{\tilde{R}_1}} E(\tilde{R}_1) + e^{i\vb{k}\cdot \vb{\tilde{R}_2}} E(\tilde{R}_2) + e^{i\vb{k}\cdot \vb{\tilde{R}_3}} E(\tilde{R}_3) \\
&\phantom{{}={}} + e^{i\vb{k}\cdot \vb{\tilde{R}_4}} E(\tilde{R}_4) + e^{i\vb{k}\cdot \vb{\tilde{R}_5}} E(\tilde{R}_5) + e^{i\vb{k}\cdot \vb{\tilde{R}_6}} E(\tilde{R}_6) \end{aligned}

将参数代入 \(H^{\text{NNN}}\) 和 \(H^{\text{TNN}}\) 中，即可得到第三近邻模型下的能带结构。需要注意的是，在使用第三近邻模型时， \(H^{\text{on-site}}\) 与 \(H^{\text{NN}}\) 的参数也需要更新。

能带求解

这里同样使用刘贵斌教授给出的数值：

参数	文献符号	数值 (eV)	参数	文献符号	数值 (eV)
\(\epsilon_1\)	\(\epsilon_1\)	0.683	\(t_{13}\)	\(t_2\)	0.506
\(\epsilon_2\)	\(\epsilon_2\)	1.707	\(t_{22}\)	\(t_{11}\)	0.085
\(t_{11}\)	\(t_0\)	-0.146	\(t_{23}\)	\(t_{12}\)	0.162
\(t_{12}\)	\(t_1\)	0.114	\(t_{33}\)	\(t_{22}\)	0.073

\(r_{11}\)	\(r_0\)	0.060	\(r_{22}\)	\(r_{11}\)	0.016
\(r_{12}\)	\(r_1\)	-0.236	\(r_{23}\)	\(r_{12}\)	0.087
\(r_{21}\)	\(r_2\)	0.067

\(u_{11}\)	\(u_0\)	-0.038	\(u_{22}\)	\(u_{11}\)	0.266
\(u_{12}\)	\(u_1\)	0.046	\(u_{23}\)	\(u_{12}\)	-0.176
\(u_{13}\)	\(u_2\)	0.001	\(u_{33}\)	\(u_{22}\)	-0.150

可得能带图如下：

显然，这次模型所得能带与 DFT 符合的很好，这说明考虑次近邻跳跃与第三近邻跳跃后的三能带模型已经可以很好地满足带边的描述需求。

自旋-轨道耦合的引入

在前面的讨论中，我们构建了一个仅包含轨道自由度的紧束缚模型。然而，对于单层 TMD 材料而言，自旋轨道耦合 (spin-orbit coupling, SOC) 不仅仅是一种微小的能量修正，它是决定能带精细结构以及谷激子性质的关键因素，因此我们有必要研究如何将 SOC 引入紧束缚模型。

原子内 SOC 的基本形式

所谓自旋轨道耦合，就是电子的自旋角动量与轨道角动量相互作用的一种狭义相对论效应。当电子在原子核产生的电场中高速运动时，相对论效应会使其感应出有效磁场，这种磁场与电子自身的自旋磁矩产生相互作用，从而导致能级分裂和谱线精细结构的产生。⁶

SOC 的通用形式为

\begin{equation} H^{\text{SOC}} = \frac{\hbar}{4mc^2} \sigma \vdot \vb{p} \cp \grad{v}(\vb{r}) \end{equation}

其中:

\(\sigma\) 是泡利矩阵；
\(\vb{p}\) 是电子的动量；
\(v(\vb{r})\) 是电子感受到的静电势；

在真实体系中，这个表达中的 \(\grad{v(\vb{r})}\) 并不容易得到，因此我们将它与前面的系数合并为 \(\lambda\) 作为一个经验参数给出此时 SOC 可以写成

\begin{equation} H_{\text{atom}}^{\text{SOC}} = \lambda \vb{L} \vdot \vb{S} \end{equation}

其中：

\(\lambda = \frac{\grad{v(\vb{r})}}{2mc^2}\) 表示 SOC 作用的强度，它决定了 SOC 对能级劈裂的贡献；
\(\vb{L}\) 是电子的轨道角动量；
\(\vb{S} = \frac{\hbar}{2} \sigma\) 是电子的自旋角动量。

我们将用这个式子对紧束缚模型中的 SOC 作用进行建模。需要指出的是，一般认为 SOC 仅作用于 on-site 项，即它只作用于同一个原胞内的同一个原子，不涉及跳跃项。

三能带模型中的 SOC 作用

在三能带模型中，我们选取的轨道基组为

\begin{equation} \qty{ \ket{d_{z^2}},\; \ket{d_{xy}},\; \ket{d_{x^2-y^2}} } \end{equation}

当 \(\vb{L}\) 算符作用到它们时， \(L_x\) 与 \(L_y\) 分量所得结果可能会得到 \(\ket{d_{yz}}\) 、 \(\ket{d_{xz}}\) 分量，而这些分量并不在三能带模型的基组内；相反，当使用 \(\ket{L_z}\) 算符作用时，所得结果仍可用现有的基组表达。因此在三能带近似下，可以将 \(m_z\) 视为一个好量子数， SOC 被简化为⁷

\begin{equation} H^{\text{SOC}} = \lambda L_z S_z \end{equation}

下面我们来讨论三能带基组下 SOC 的矩阵元。

\(L_z\) 算符

对于各个实轨道，它们都可以写成复球谐函数的线性组合：

\(\ket{d_{z^2}} = Y_{2,0}\)
\(\ket{d_{xy}} = \frac{i}{\sqrt{2}} (Y_{2,-2} - Y_{2,2})\)
\(\ket{d_{x^2-y^2}} = \frac{1}{\sqrt{2}} (Y_{2,-2} + Y_{2,2})\)

对每个球谐函数，有⁸

\begin{equation} L_z Y_{lm} = m Y_{lm} \end{equation}

将 \(L_z\) 作用于实轨道时，有

\(\hat{L}_z \ket{d_{z^2}} = 0\)
\(\hat{L}_z \ket{d_{xy}} = \frac{i}{\sqrt{2}} (-2 Y_{2,-2} - 2 Y_{2,2}) = -2i \frac{1}{\sqrt{2}} (Y_{2,-2} + Y_{2,2}) = -2i \ket{d_{x^2-y^2}}\)
\(\hat{L}_z \ket{d_{x^2-y^2}} = \frac{1}{\sqrt{2}} (-2 Y_{2,-2} + 2 Y_{2,2}) = 2i \frac{-i}{\sqrt{2}} (-Y_{2,-2} + Y_{2,2}) = 2i \ket{d_{xy}}\)

因此， \(\hat{L}_z\) 的矩阵元 \(\mel{i}{\hat{L}_z}{j}\) 中有以下关系

\(\mel{d_{z^2}}{\hat{L}_z}{j} = 0\)
\(\mel{d_{xy}}{\hat{L}_z}{d_{x^2-y^2}} = \mel{d_{x^2-y^2}}{\hat{L}_z}{d_{xy}}^* = 2i\)
\(\mel{d_{xy}}{\hat{L}_z}{d_{xy}} = \mel{d_{x^2-y^2}}{\hat{L}_z}{d_{x^2-y^2}} = 0\)

把上面的关系写成矩阵形式有

\begin{equation} L_z = \begin{bmatrix} 0 & 0 & 0 \\
0 & 0 & 2i \\
0 & -2i & 0 \end{bmatrix} \end{equation}

\(S_z\) 算符

由于我们忽略了 \(L_x\) 与 \(L_y\) 的贡献，因此电子自旋也只需考虑 \(S_z\) 的贡献

\begin{equation} S_z = \frac{1}{2} \sigma_z = \begin{bmatrix} \frac{1}{2} & 0 \\
0 & -\frac{1}{2} \end{bmatrix} \end{equation}

此时我们可以得到完整的 SOC 矩阵

\begin{aligned} H^{\text{SOC}} &={} \lambda S_z \otimes L_z \\
&={} \begin{bmatrix} \frac{\lambda}{2} L_z & 0 \\
0 & -\frac{\lambda}{2} L_z \end{bmatrix} \end{aligned}

这里我们相当于引入了新的自由度，即自旋，因此需要使用克罗内克积(Kronecker Product, 也称“直积”) 符号 \(\otimes\) ⁹。

考虑自旋轨道耦合后的能带

前面我们已经得到了紧束缚模型的 Hamiltonian \(H^0\) 和完整的 SOC 矩阵 \(H^{\text{SOC}}\) ，现在可以将它们组合起来

\begin{aligned} H^{\text{TB+SOC}}(\vb{k}) &={} I_2 \otimes H^0(\vb{k}) + H^{\text{SOC}} \\
&={} \begin{bmatrix} H_0 + \frac{\lambda}{2} L_z & 0 \\
0 & H_0 - \frac{\lambda}{2} L_z \end{bmatrix} \end{aligned}

这里 \(I_2 = \bmqty{1 & 0 \\ 0 & 1}\) 表示单位矩阵。

借用刘贵斌教授 Phys. Rev. B 给出的数值， MoS₂ 中 \(\lambda = 0.073\) ，代入 \(H^{\text{TB+SOC}}\) 中，可得能带如图5 所示

Figure 5: 包含 SOC 后 DFT 能带图与第三邻模型的对比。

不难看出，在包含 SOC 后，三能带模型与 DFT 计算结果仍然符合地不错。比如 K 谷里 VBM 较大的劈裂和 CBM 微小的劈裂都被良好地复现出来，而 \(\Gamma\) 谷 VBM 存在简并的特性也一样得到保留。这说明在只取 \(L_z\) 近似下的 SOC 就可以描述出较为合理的自旋轨道劈裂。

参数的拟合

到目前为止，我们的模型在建立好之后一直依赖查文献来获取模型的参数，这对于 MoS₂ 这样已经十分熟悉的体系而言是没什么问题的，但对于一个文献鲜有报道的体系，我们就不得不自己来拟合这些参数。

我们来简化一下这个问题，它等同于：

有一个函数 \(f\) ，它接受一个参数集 \(\{p\}\) 并输出结果 \(E\) ，现在求一个 \(\{p\}\) 使得 \(E\) 尽可能接近目标值 \(E^0\) ，即

\begin{equation} \min_{p} \sum_{\vb{k}} \bqty{ f_{\vb{k}}(\{p\}) - E_{\vb{k}}^0 }^2 \end{equation}

其中 \(f\) 即为紧束缚模型；

\(\qty{p} = \qty{\epsilon_1, \epsilon_2, t_{11}, …}\) ；

\(E^0\) 为目标能带的具体数值。

这是一个典型的最优化问题，直接交给程序去完成即可。

目标能带

这里我们以 MoS₂ 为例演示如何通过拟合 HSE 能带（不带 SOC）得到三能带紧束缚模型的参数值。图 6 中突出显示的即为目标能带。

Figure 6: 使用 DFT + HSE06 计算得到的 MoS₂ 能带及选取的目标能带

构造损失函数

损失函数的构造其实相当简单，只需

\begin{equation} f_{\text{loss}}\bqty{p} = \sum_{n,\vb{k}} \abs{ E\bqty{p}(n, \vb{k}) - E_0(n, \vb{k}) }^2 \end{equation}

其中 \(E\bqty{p}(n, \vb{k})\) 是在当前参数空间 \(p\) 中计算所得能带值。这个损失函数其实就表示当前能带“距离目标能带有多远”，式中 \(||^2\) 就表示求两个量的欧氏距离。

程序设计和计算结果

这里我们使用 Julia 的 Optim.jl 包，大概流程如下

# Evaluate bands, pvec is the vector of TB params
function forward_bands(pvec, kpath, model, ...)
    # Const and diagonalize the Hamiltonian
    Hk = ...
    E = eigvals!(Hk)
    return E
end

# Loss function
function make_loss(Etarget, kpath, model, cache)
    function loss(pvec)
        Etb = forward_bands(pvec, kpath, model, cache)
        s = 0.0
        @inbounds for b in 1:3, i in 1:size(Etb,2)
            d = Etb[b,i] - Etarget[b,i]
            s += w * d*d
        end
        return s
    end
    return loss
end

# main function
loss = make_loss(Etarget, kpath, model, cache; mask=mask, p0=p0, reg=reg, nsegs=nsegs)

# 1) Coarse: Nelder-Mead (robust, no gradients)
res1 = optimize(loss, p0, NelderMead())
p1 = Optim.minimizer(res1)
@info "After NelderMead: loss = $(Optim.minimum(res1))"

# 2) Refine: BFGS (fast local)
res2 = optimize(loss, p1, BFGS(), Optim.Options(show_trace=true))
p_opt = Optim.minimizer(res2)
@info "After BFGS: loss = $(Optim.minimum(res2))"

在上面的代码中，我们先用 NelderMead 方法进行快速地粗优化，然后在此基础上使用 BFGS 算法进行更精细地优化，拟合所得参数如下

参数	文献符号	数值 (eV)	参数	文献符号	数值 (eV)
\(\epsilon_1\)	\(\epsilon_1\)	1.126	\(t_{13}\)	\(t_2\)	0.653
\(\epsilon_2\)	\(\epsilon_2\)	2.211	\(t_{22}\)	\(t_{11}\)	0.205
\(t_{11}\)	\(t_0\)	-0.208	\(t_{23}\)	\(t_{12}\)	0.231
\(t_{12}\)	\(t_1\)	-0.203	\(t_{33}\)	\(t_{22}\)	0.065

\(r_{11}\)	\(r_0\)	0.055	\(r_{22}\)	\(r_{11}\)	0.023
\(r_{12}\)	\(r_1\)	-0.271	\(r_{23}\)	\(r_{12}\)	0.107
\(r_{21}\)	\(r_2\)	0.040

\(u_{11}\)	\(u_0\)	-0.015	\(u_{22}\)	\(u_{11}\)	0.267
\(u_{12}\)	\(u_1\)	0.064	\(u_{23}\)	\(u_{12}\)	0.184
\(u_{13}\)	\(u_2\)	0.026	\(u_{33}\)	\(u_{22}\)	0.179

其对应的能带结果如下

Figure 7: MoS₂ 中 HSE06 能带与 TNN 模型能带对比

不难看出，用拟合参数计算得到的能带与 HSE 能带在 Γ 谷和 K 谷符合地非常好，但在 M 与 M' 谷及附近还存在 ~15meV 左右的差距，尽管如此，笔者依然认为这是一个相当好的结果，至少证明了我们的程序是可用的。

模型的局限性

至此，我们已经给出了单层 TMD 体系中三能带紧束缚模型的完整构建过程，并证明该模型能够较好地再现 K/K' 谷附近的低能电子结构。然而，在模型构建过程中我们不可避免地引入了一系列假设与近似，这也意味着该模型的适用性存在明确的边界。本节将系统总结三能带模型的适用范围，并讨论其主要局限性。

三能带模型仅保留了过渡金属（M）原子的 \(\ket{d_{z^2}},\; \ket{d_{xy}},\; 和 \ket{d_{x^2-y2}}\) 三个轨道。在这一近似下，该模型能够较为准确地描述 K/K' 谷附近、费米能级上下若干电子伏特范围内的能带性质，包括带隙大小、有效质量以及价带的自旋-轨道耦合劈裂等关键物理量。

然而，在以下情形中，三能带模型的局限性会逐渐显现：

在 Γ 点附近，导带底（CBM）往往不再由所选取的三条金属 d 轨道主导。若希望正确描述 Γ 谷附近的能带结构，必须在基组中引入更多轨道自由度，例如硫（或硒）原子的 p 轨道或金属原子的其它 d 轨道；
当 \(\vb{k}\) 远离 K/K′ 点（例如靠近 M/M' 谷）时，三能带模型对能带色散关系的描述精度明显下降；
对于远离费米能级的高能能带，该模型本身并不具备描述能力，此时应考虑采用多能带模型，甚至使用 Wannier 轨道基；
在当前模型中，自旋–轨道耦合仅以 on-site 项的形式引入，并忽略了 \(L_x\) 和 \(L_y\) 分量以及可能存在的 inter-site SOC，这一近似在研究精细自旋结构或强外场效应时可能不再充分；
模型的结构高度依赖于单层 TMD 材料所具有的 \(D_{3h}\) 点群对称性。一旦体系的对称性被破坏，例如施加垂直电场或磁场、引入单轴应变、构造异质结或莫尔超结构，原有的对称性约束将不再成立，此时整个模型需要重新审视甚至重新构建。换言之，该模型在不同体系之间的泛用性是有限的。

以上讨论总结了三能带紧束缚模型的主要局限性。在实际研究中，只要所关注的物理问题处于其适用范围之内，这一模型依然是一个结构简洁、物理清晰且行之有效的理论工具。

总结

本文以单层 TMD 材料的三能带紧束缚模型为核心，系统介绍了该模型的构建思路与实现过程。我们从晶体结构与对称性分析出发，依次讨论了轨道基组的选择、紧束缚哈密顿量的构建方法以及自旋-轨道耦合的引入方式，展示了如何在最小基组的框架下刻画 TMD 体系中最受关注的带边电子结构。

三能带模型之所以具有代表性，主要体现在以下几个方面：

单层 TMD 的导带底与价带顶主要由金属原子的三条 \(d\) 轨道贡献，其它原子及轨道的影响可以在低能近似下被有效吸收，从而保留了带隙起源及带边态的本征轨道性质；
尽管模型中未显式包含硫（或硒）原子的轨道自由度，但金属原子之间的有效跃迁参数已经隐式地包含了 M–X–M 路径的贡献；
在模型构建的全过程中，对称性始终作为首要约束条件，这显著减少了自由参数数量，并保证了模型结构与物理结果的一致性。

凭借其简洁而不失物理内涵的特点，三能带紧束缚模型不仅是研究单层 TMD 能谷物理的重要工具，也非常适合作为紧束缚建模方法的入门示例。通过这一模型，人们可以清晰地看到如何在复杂材料体系中提炼出最关键的自由度，并在可控近似下建立具有明确物理解释力的有效理论。

待续

既然已经提到了紧束缚模型，那只用它算个能带未免有点太浪费了，后面可能会考虑做以下几个实验（也可能没时间做）

贝里联络、贝里曲率的计算；
引入二体相互作用（主要是电子电子、电子空穴的库仑直接项与交换项）；
实现一个半导体布洛赫方程；
对 TMD 中的高次谐波等非线性光学性质进行模拟；

代码下载

文中所有代码已经打包到 code.zip 其中包括：

计算能带脚本： tmd-tb-main.jl
画图脚本： tmd-plot.py
TMD 紧束缚模型的参数: tmd-params.toml ¹⁰
拟合 HSE 能带的脚本： tmd-fit-params.jl
MoS₂ 使用 DFT 计算得到的能带信息，这里不一一列举。

其中大部分代码是在我已经写好的基础上使用 ChatGPT 优化所得，因此需要给到 ChatGPT 部分 credit ，在此表示感谢。

致谢

刘贵斌教授：本文基本属于他那篇 Phys. Rev. B 的复现；
nguyn21012003：他是正在越南一所高校就读的研一大佬，他的仓库对本文帮助很大；
长岛冰茶109：茶佬帮助解决了困扰我很久的跳跃矩阵对称性约束问题；

Liu, G.-B.; Shan, W.-Y.; Yao, Y.; Yao, W.; Xiao, D. Three-Band Tight-Binding Model for Monolayers of Group-VIB Transition Metal Dichalcogenides. Phys. Rev. B 2013, 88 (8), 085433. https://doi.org/10.1103/PhysRevB.88.085433 . ↩︎
这是因为 \(\ket{d_{xy}}\) 与 \(\ket{d_{x^2-y^2}}\) 构成了 \(C_3\) 群中 \(E\) 不可约表象的完备基函数。原谅我因为不会群论，不得不这样绕一下来讲 \(C_3\) 转动群的不可约表示。 ↩︎
这个对称操作矩阵其实可以从 Wigner D 矩阵得到。 https://en.wikipedia.org/wiki/Wigner_D-matrix ↩︎
确切地说，受 LCAO 的三条原则（对称性匹配原则、最大重叠原则和能量相近原则）中对称性匹配原则的约束， \(\ket{d_{z^2}}\) 与 \(\ket{d_{xy}}\) 以及 \(\ket{d_{x^2-y^2}}\) 对于 \(xy\) 平面的反映 \(\sigma_h\) 都是偶对称性，而其它的 \(d\) 轨道，即 \(\ket{d_{xz}}\) 和 \(\ket{d_{yz}}\) 轨道对于 \(\sigma_h\) 则是奇对称性，两者对称性不匹配，所以文中选取的 \(d\) 轨道与其它 \(d\) 轨道的耦合严格为 0 ；因此在选择该基组后已经约束了所有轨道都是 \(\sigma_h\) 偶对称，也就是不需要考虑 \(\sigma_h\) 操作。其它与 \(z\) 相关的对称操作也是如此。 ↩︎
这里如果将不同不可约表示的对称算符分开写会更符合群论"原理"，但考虑到本人不熟悉群论，以及这个系统本身轨道数不多，就不那样处理了。 ↩︎
这段话来自 Wiki https://en.wikipedia.org/wiki/Spin%E2%80%93orbit_interaction 。 ↩︎
等价于我们限制了自旋的取向为 \(\pm z\) ，因此这其实可以看成一种伊辛模型 (Ising model) 近似。 ↩︎
这里取 \(\hbar = 1\) ，因此量纲没表现出来。 ↩︎
https://en.wikipedia.org/wiki/Kronecker_product ↩︎
这份参数表源自刘贵斌老师的 Phys. Rev. B ，由于 GitHub 用户 @nguyn21012003 整理，详见这个仓库。 ↩︎

一起动手算原子弹的临界质量

Thu, 18 Sep 2025 21:27:00 +0800

Table of Contents

偶然看到了 Dr. Jorge S. Diaz 关于如何计算原子弹临界质量的视频，觉得挺有意思，于是稍微记录一下推导过程。下面这个公式就是整篇文章的核心。 \[ \frac{\partial N}{\partial t} = \frac{(\nu - 1)}{\tau} N + \frac{\lambda_t \lambda_f}{3\tau} \nabla^2 N \]

问题假设及目标

既然是要算原子弹的临界质量，我们要先明确问题的条件（假设）以及问题的目标。我们先看原子弹的定义：

所谓原子弹，又称裂变弹，是利用铀、钚等可裂变物质的核裂变反应释放巨大能量而制成的爆炸装置。 — Wikipedia

从定义可知，原子弹主要利用到了核裂变(fission)。所谓核裂变，以 U-235 为例，就是一个 U-235 原子在吸收一个中子(neutron)后，变成不稳定的 U-236 ，最后迅速分解为一个 Kr-92 原子、一个 Ba-141 原子，以及释放出三个中子；而这三个中子随后会继续轰击其它 U-235 原子，继续得到更多的中子，从而在短时间内使系统内发生裂变的原子数量呈指数极增加，在这个过程释放出巨大的能量，这个过程表现在宏观上就是“爆炸”。

Figure 1: U-235 的裂变反应示意图

在上面的分析中，我们不难看出，问题的关键在于中子的数量，准确地讲是弹体中的中子分布密度。如果中子分布密度可以随时间指数级地递增，那么链式反应就能发生，原子弹就可以爆炸；反之，如果中子分布密度随时间递减，则原子弹不会爆炸。因此我们将问题简化为求解关于弹体内中子分布密度函数的微分方程。

为此我们不妨做出下面假设：

弹体由均匀的 U-235 组成；
弹体为球形；
弹体中的中子分布密度用含时函数 \(N(\vb{r}, t)\) 表示；
弹体边界处的中子分布密度为0；
中子在遇到 U-235 原子时可能会被吸收引发裂变，也可能发生弹性散射被弹开；

求解目标为：

求解关于 \(N(\vb{r}, t)\) 的微分方程，给出维持链式反应最小质量（临界质量）。至于这个方程长什么样，我们还不得而知。

中子扩散方程的导出

取弹体中的任意一点 \(\vb{r}\)，它经中子密度为 \(N(\vb{r}, t)\) ，如果此时没有中子被原子吸收，也没有其它的原子产生中子，则中子数守恒， \(\vb{r}\) 处的中子密度满足 流体连续性方程 ：

\begin{equation} \label{eq:continuity-eq} \pdv{N}{t} + \divergence \vb{J} = 0 \end{equation}

公式\eqref{eq:continuity-eq} 中 \(\vb{J}\) 是中子流密度，它代表了单位时间内中子流过某个点的数量，而 \(\divergence N = \pdv{N_x}{x} + \pdv{N_y}{y} + \pdv{N_z}{z}\) 则表示求它的散度。这个公式的含义是在任意一点增加的中子数量等于其流出的中子数量，也即中子数守恒¹。

公式\eqref{eq:continuity-eq} 中的 \(\vb{J}\) 可以从菲克扩散定律(Fick’s law of diffusion)推出：

粒子从高浓度区向低浓度区的流动速率正比于浓度梯度。 — 菲克定律

将菲克定律应用于中子分布密度，可以得到

\begin{equation} \label{eq:fick-law} \vb{J} = - D \grad N \end{equation}

公式\eqref{eq:fick-law} 中 \(\grad N\) 表示求中子的浓度梯度； \(D\) 为扩散常数，它的量纲是 \(\frac{\text{长度}^2}{时间}\) ²，代表了中子扩散的强弱。一般中子的扩散常数可以使用下面的式子计算

\begin{equation} D = \frac{1}{3} \lambda_t \expval{v} \end{equation}

其中 \(\lambda_t\) 表示中子输运的平均自由程（即发生两次裂变之间中子经过路程的平均值， \(t\) 表示 transport）； \(\expval{v}\) 表示中子的平均运动速率，它可以使用下面的式子近似计算

\begin{equation} \expval{v} = \frac{\lambda_f}{\tau} \end{equation}

其中 \(\lambda_f\) 表示裂变时中子的平均自由程。自由程可以使用宏观的散射截面来计算³：

\begin{equation} \begin{aligned} \lambda = \frac{1}{\Sigma} = \frac{1}{N \sigma} = \frac{1}{(\rho N_A/M) \sigma} = \frac{M}{\rho N_A \sigma} \end{aligned} \end{equation}

其中 \(\Sigma\) 是宏观散射截面，\(N\) 是单位体积内的原子核数量， \(\sigma\) 是微观散射截面， \(\rho\) 是宏观密度， \(N_A\) 是阿伏加德罗常数， \(M\) 是原子相对质量。对于裂变自由程 \(\lambda_f\) ，其微观散射截面就是裂变散射截面 \(\sigma_f\) ；而对于输运自由程 \(\lambda_t\) ，其微观散射截面就是裂变散射截面由裂变散射截面和弹性散射截面共同组成 (\(\sigma_t = \sigma_f + \sigma_e\)) 。

但在原子弹中，中子可以被 U-235 吸收，也可以通过裂变产生，那么中子数量并不守恒，因此这个方程的右手边需要加入中子产生项和中子吸收项：

\begin{equation} \label{eq:continuity-eq-with-source} \pdv{N}{t} + \divergence \vb{J} = S_+ - S_- \end{equation}

公式\eqref{eq:continuity-eq-with-source} 的右手边 \(S_+\) 表示产生的中子数， \(S_-\) 表示吸收的中子数，它们分别可以写为

\begin{align} \label{eq:neutron-source-sink-term} S_+ &={} \nu \frac{N}{\tau} \quad \text{裂变产生的中子} \\
S_- &={} \frac{N}{\tau} \quad \text{裂变消耗的中子} \end{align}

式\eqref{eq:neutron-source-sink-term} 中 \(\nu\) 表示每次裂变反应生成的中子数，而 \(\tau\) 表示平均发生两次裂变反应的间隔时间。

现在我们把公式\eqref{eq:continuity-eq-with-source} 各项都展开，有 \[ \pdv{N}{t} + \divergence (-D \grad N) = \frac{(\nu - 1)}{\tau} N \] 使用矢量运算关系式 \(\divergence (\grad N) = \laplacian N = \pdv[2]{N}{x} + \pdv[2]{N}{y} + \pdv[2]{N}{z}\) ，以及代入扩散常数 \(D\) 的表达式，对中子扩散方程进行整理，可以得到文章开头的那个公式

\begin{equation} \label{eq:neutron-diffusion-equation} \pdv{N}{t} = \frac{(\nu - 1)}{\tau} N - \frac{\lambda_t \lambda_f}{3\tau} \laplacian N \end{equation}

这便是中子扩散方程，也是我们计算原子弹临界质量的理论基础。下面我们来解这个方程，并推导出临界质量。

中子扩散方程的求解

不妨仔细观察这个方程，我们把需要求的变量用红色标出 \[ \pdv{\color{red}N}{t} = \frac{(\nu - 1)}{\tau} {\color{red}N} - \frac{\lambda_t \lambda_f}{3\tau} \laplacian {\color{red}N} \] 不难看出这是一个关于 \(N\) 的偏微分方程，议程左边只依赖于时间 \(t\) ，右边只依赖于空间坐标 \(x,y,z\) ，因此可以使用分离变量法来求解。我们可以将 \(N(\vb{r}, t)\) 写成两个函数的积，其中 \(f(\vb{r})\) 只与位置 \(\vb{r}\) 有关， \(g(t)\) 只与时间 \(t\) 相关：

\begin{equation} \label{eq:variable-separation} N(\vb{r}, t) = f(\vb{r}) g(t) \end{equation}

此时将公式\eqref{eq:variable-separation} 代入方程\eqref{eq:neutron-diffusion-equation} ，可得

\begin{aligned} & f \pdv{g}{t} = \frac{\nu - 1}{\tau} fg + \frac{\lambda_t \lambda_f}{3\tau} (\laplacian f)g \\
\implies & \frac{1}{g} \pdv{g}{t} = \frac{\nu - 1}{\tau} + \frac{\lambda_t \lambda_f}{3\tau} \frac{\laplacian f}{f} \equiv K = \frac{\nu'}{\tau} \end{aligned}

我们得到两个关系式

\begin{gather} \frac{1}{g} \pdv{g}{t} = \frac{\nu'}{\tau} \label{eq:g-pde} \\
\frac{\nu'}{\tau} = \frac{(\nu - 1)}{\tau} + \frac{\lambda_t \lambda_f}{3\tau} \frac{\laplacian f}{f} \label{eq:nu-prime-definition} \end{gather}

其中方程\eqref{eq:g-pde} 是只关于 \(g\) 的微分方程，且方程右边与 \(g\) 无关，故我们将等式右边重新定义为 \(\frac{\nu'}{\tau}\) ，其具体形式如公式\eqref{eq:nu-prime-definition} 所示。

时间演化方程

\(g\) 只与时间相关，所以式\eqref{eq:g-pde} 是中子分布密度的时间演化方程，它也是一个典型的常微分方程，我们可以轻松写出它的通解

\begin{align} \frac{1}{g} \dv{g}{t} &={} \frac{\nu'}{\tau} \notag \\
\implies \dv{\ln{g}}{t} &={} \frac{\nu'}{\tau} \notag \\
\implies g(t) &={} A e^{\nu’t/\tau} \label{eq:g-solution} \end{align}

公式\eqref{eq:g-solution} 显示 \(g\) 是一个指数函数，虽然其指前因子 \(A\) 与指数部分 \(\nu'\) 待定，但现在我们至少可以得出一个结论，即要想中子的数量短时间大量扩增， \(g\) 必须为增函数，即指数 \(\nu'\) 必须为正，否则 \(g\) 是减函数，中子数量会逐渐衰减。 Alex Wellerstein 制作了一个网站用于演示裂变反应的具体过程，它可以生动地反映当 \(\nu'\) 大于零以及小于零时系统中裂变反应的剧烈程度，读者有兴趣可以尝试⁴。

空间分布方程

下面我们来求解 \(f\) ，其只与 \(x,y,z\) 有关，因此它描述的是中子的空间分布。对公式\eqref{eq:nu-prime-definition} 进行化简，我们可以得到关于 \(f\) 的微分方程：

\begin{align} &\frac{\nu'}{\tau} = \frac{(\nu - 1)}{\tau} + \frac{\lambda_t \lambda_f}{3\tau} \frac{\laplacian f}{f} \notag \\
\implies & \frac{\lambda_t \lambda_f}{3\tau} \frac{\laplacian f}{f} + \frac{\nu - 1 - \nu'}{\tau} = 0 \notag \\
\implies & \laplacian f + \pqty{\frac{3(\nu - \nu' - 1)}{\lambda_t \lambda_f}} f = 0 \notag \\
\implies & \laplacian f + \kappa^2 f = 0 \label{eq:f-equation} \end{align}

方程\eqref{eq:f-equation} 类似振子振动的方程，其中 \(f\) 前面的系数我们用 \(\kappa^2 = \pqty{\frac{3(\nu - \nu' - 1)}{\lambda_t \lambda_f}}\) 表示。

由于弹体是球形，系统具有球对称性，我们在球坐标系下求解这个方程会更容易：

\begin{equation} f(\vb{r}) = f(r, \theta, \phi) \equiv f( r) \end{equation}

这里我们舍去角向的 \(\theta, \phi\) 部分，只考虑径向 \(r\) 的分布。拉普拉斯算符在球坐标系下可以转化为

\begin{equation} \label{eq:spherical-laplacian} \laplacian f = \frac{1}{r^2} \dv{}{r} \pqty{ r^2 \dv{f}{r} } \end{equation}

如果直接将公式\eqref{eq:spherical-laplacian} 代入方程\eqref{eq:f-equation} ，则很难求解这个微分方程，因此这里使用一个辅助函数 \(u( r) = r f( r)\) 使得 \(f( r) = u( r) / r\) ，此时

\begin{equation} \label{eq:laplacian-auxiliary} \laplacian f = \frac{1}{r} \dv[2]{u}{r} \end{equation}

将式\eqref{eq:laplacian-auxiliary} 代入公式\eqref{eq:f-equation} ，可得

\begin{equation} \label{eq:u-function} \dv[2]{u}{r} + \kappa^2 u = 0 \end{equation}

不难解得

\begin{equation} \label{eq:u-solution} u( r) = B \cos(\kappa r) + C \sin(\kappa r) \end{equation}

将 \(u\) 代回 \(f( r) = u( r) / r\) ，可得

\begin{equation} \label{eq:f-solution} f( r) = B \frac{\cos(\kappa r)}{r} + C \frac{\sin(\kappa r)}{r} \end{equation}

此时关于 \(N\) 的两个分量都有了表达式，将式\eqref{eq:g-solution} 与式\eqref{eq:f-solution} 合并，可得 \(N\) 关于半径和时间的函数关系式

\begin{gather} N(r, t) = A e^{\nu' t/\tau} \pqty{B \frac{\cos(\kappa r)}{r} + C \frac{\sin(\kappa r)}{r}} \\
\kappa^2 = \frac{3(\nu - \nu' - 1)}{\lambda_t \lambda_f} \label{eq:kappa-squared} \end{gather}

这个式子还是有些复杂，并且还包含更多待定的因子，如 \(A, B, C\) 等，我们需要利用边界条件对它进行化简。

边界条件

弹体中心处的中子密度是有限的；

这要求 \(N(r=0,t) \ne \infty\) ，考虑到 \(\displaystyle \lim_{r\to 0} B \frac{\cos(\kappa r)}{r} \to \infty\) ，因此 \(B\) 必须为零；而 \(\displaystyle \lim_{r\to 0} C \frac{\sin(\kappa r)}{r} \to C \kappa\) ，因此 \(C \ne 0\) 。
弹体中心处的初始中子密度为 \(N_0\) ；

即 \(N(r=0, t=0) = N_0\) ，对应于 \(\displaystyle \lim_{\substack{r\to 0 \\ t \to 0}} N(r,t) = AC\kappa\) ，由此可以推出 \(AC = \frac{N_0}{\kappa}\) 。
弹体足够大，以至边界处的中子数为零。

即 \(N(r=R, t) = N_0 e^{\nu’t/\tau} \pqty{\frac{\sin(\kappa R)}{\kappa R}} = 0\) ，上面的式子要求满足 \(\sin(\kappa R) = 0\) ，因此可以取 \(\kappa = \frac{\pi}{R}\) 。结合前面我们得到的 \(\kappa^2\) 关系式，我们可以求出待定参数 \(\nu'\)

\begin{gather} \kappa^2 = \frac{3(\nu - \nu' - 1)}{\lambda_t \lambda_f} = \frac{\pi^2}{R^2} \notag \\
\implies \nu' = (\nu - 1) - \frac{\pi^2 \lambda_t \lambda_f}{3R^2} \notag \end{gather}

临界质量的导出

在上一节，我们得到了关于 \(\nu'\) 的表达式，而我们在时间演化方程那一节曾讨论过，原子弹爆炸的一个必要条件是 \(\nu' > 0\) ，因此我们可以得到弹体的临界半径

\begin{gather} \nu' = (\nu - 1) - \frac{\pi^2 \lambda_t \lambda_f}{3R^2} = 0 \label{eq:nu-prime-condition} \\
\implies R_c = \pi \sqrt{\frac{\lambda_t \lambda_f}{3(\nu - 1)}} % = \frac{\pi M}{\rho N_A} \pqty{\frac{1}{3\sigma_t \sigma_f (\nu-1)}}^{1/2}\\
\end{gather}

进而根据半径算出体积，以及临界质量的表达式

\begin{equation} \implies M_c = \frac{4}{3} \pi \rho R_c^3 % = \frac{4\pi^4 M^3}{3\rho^2 N_A^3} % \pqty{\frac{1}{3\sigma_t \sigma_f (\nu - 1)}}^{3/2} \end{equation}

代入实验上测得的微观数据

数据名称	符号	数值
中子寿命（平均两次裂变反应间隔时间）	\(\tau\)	16.5 ns
平均每次裂变产生的中子数	\(\nu\)	2.6
中子输运自由程	\(\lambda_t\)	3.596 cm
中子裂变自由程	\(\lambda_f\)	16.89 cm
铀-235 的密度	\(\rho\)	19.050 g/cm³

可以计算得到临界半径和临界质量分别为

\begin{gathered} R_c \approx 11 \, \text{cm} \\
M_c \approx 106 \, \text{kg} \end{gathered}

以上是一种“基础解”，它简单地要求边界处的中子数为零，这个条件过于严格。如果我们放宽边界条件的限制，其临界质量也会有所变化。另一种常用的边界条件是在边界处允许一半的中子流逃逸到弹体外面，即

\begin{gather} J( R) = -D \pdv{\phi}{r}\bigg|_R \ge \frac{1}{2} \phi( R), \quad \phi( r) = N( r) \expval{v} \notag \\
\implies N(r=R, t) \le - \frac{2}{3} \lambda_t \pdv{N}{r}\bigg|_{r=R} \label{eq:marshak-bc} \end{gather}

式\eqref{eq:marshak-bc} 也被称为 Marshak 边界条件⁵，此时可以得到

\begin{equation} \frac{3R}{2\lambda_t} \le 1 - \frac{\kappa R}{\tan (\kappa R)} \label{eq:marshak-critical-radius} \end{equation}

联系到我们使用公式\eqref{eq:nu-prime-condition} 求临界质量时要求 \(\nu' = 0\) ，这里我们也使用这个条件，并将它与其它参数代入式\eqref{eq:kappa-squared} ，可以得到 \(\kappa\) 的具体值，然后我们可以使用计算机求解方程\eqref{eq:marshak-critical-radius} ，便可以得到一个新的临界半径 \(R_c\)，及其对应的临界质量 \(M_c\)： \[ R_c \approx 8.37\;\text{cm}; \quad M_c \approx 46\;\text{kg} \] 至此，我们得到了 Marshak 边界条件下的 U-235 原子弹临界质量，相比于实际临界质量(52 kg)⁶，这个值又偏小，说明 Marshak 边界条件又过于宽松。

小结与胡扯

以上便是从中子扩散理论出发得到的两种原子弹临界质量，分别为 106 kg 和 46 kg ，尽管它们与实际值有着不小的差别，但其推导过程仍具有启发意义。在此再次感谢 Dr. Jorge S. Diaz 博主的影片，其在视频最后还留了几道家庭作业，分别是计算钸-239的临界质量以及正方体和圆柱体弹体的临界质量。鉴于本人对做 Homework 并不感兴趣，这几道题还是留给读者吧。如果读者对其它推导方法感兴趣，可以参考这篇文献 ⁷。

稍微讲一些胡说八道吧，本文抓住了中子分布密度这一核心变量来建模整个原子弹，通过求解它的含时方程与空间分布方程，我们可以得到整个原子弹的临界半径与临界质量，这一步看似简单，但其实并不容易，需要建模人员有敏锐的直觉和丰富的经验。另外一个点是，文中推导的中子扩散方程实际是以菲克扩散定律为基础，而后者可以从微观粒子的随机行走理论推导得到，这实际上忽略了中子与中子的相互作用而只考虑了中子与铀原子核的相互作用，如果考虑中子与中子的相互作用，那么得到的临界质量又会是另外一个值。最后要说的是，推导的最后，我们仅仅改变了中子扩散方程的边界条件，所得到的临界质量就大相径庭，这说明我们在建模时不仅需要简化模型，也需要适当考虑更多的因素，这实际上相当考验建模人员的数学功底和物理直觉，至少本人自己做不到^_^。

文章结尾再送读者一篇文献⁸，如果你对海森堡算错临界质量这件事比较感兴趣可以看这篇文献，文章系统描述了二战后海森堡在和平环境下用一周的时间内算出的结果，他甚至还考虑了带中子反射层的边界条件，得到的临界质量与实验值“惊人地一致”，这也侧面说明研究环境对于研究人员状态的影响有多大。

如果把\(N\)换成质量，它也就是流体力学中的质量守恒定律； ↩︎
如果单独搜索“扩散系数”，会有资料显示它的量纲是长度 (\(D = \frac{\lambda}{3}\)， \(\lambda\) 是平均自由程)，此时 \(D\) 中的速度项被 \(\vb{J} = -D \grad \vb{\phi}\) 中的 \(\vb{\phi}\) 所吸收，详见这个链接。 ↩︎
详见 https://clive.semmens.org.uk/Energy/FreePath.html ↩︎
裂变反应模拟网站 https://blog.nuclearsecrecy.com/misc/criticality/ ↩︎
Noh, Taewan. “A Study on Diffusion Approximations to Neutron Transport Boundary Conditions.” Journal of the Nuclear Fuel Cycle and Waste Technology(JNFCWT) 16, no. 2 (2018): 203–9. https://doi.org/10.7733/jnfcwt.2018.16.2.203 . ↩︎
https://en.wikipedia.org/wiki/Critical_mass ↩︎
Reed, B. Cameron. “Estimating the Critical Mass of a Fissionable Isotope.” Journal of Chemical Education 73, no. 2 (1996): 162. https://doi.org/10.1021/ed073p162 . ↩︎
El Naschie, M.S. “Heisenberg’s Critical Mass Calculations for an Explosive Nuclear Reaction.” Chaos, Solitons & Fractals 11, no. 6 (2000): 987–97. https://doi.org/10.1016/S0960-0779(99)00110-1 . ↩︎

如何将文件打包进 C/C++/Fortran 程序内

Tue, 04 Apr 2023 00:10:00 +0800

Table of Contents

最近在写 Fortran 程序时有一个需求：把另一个文件打包进二进制里面，以便可以随时 print 出来，经过一番网上冲浪，摸索出来几个 workaround ，在此记录一下。

问题描述

现在有一个不可变的文件名为 foo.txt ，编写一个 C/C++/Fortran 程序，使得它能在任意地方打印出 foo.txt 的内容。

注意： 任意地方 也包括其它人的机器。

解决方法

直接写 `const char*`

1
2
3

const char* file_content = "Hello world\n\
with a new line here.";
puts(file_content);

缺点：麻烦，遇到换行时需要额外加 \n\ ，可以用 python 脚本生成 .c 文件来解决；如果文件为二进制，则需要手写十六进制数据。

通过 inline assembly

C 语言中每个全局变量对应一个 label ，并且这个 label 可以直接当作变量名来访问，比如

`1`	`const char str[] = "Hello world.";`

Linux 上对应的汇编代码就是

    .globl  str
    .type   str, @object
    .size   str, 13
str:
    .string "Hello world."

可见，除了一些内存对齐、类型标注等，主要起作用的还是 .section .rodata 和 number: .string "Hello world." 了，前者对应了 const ，后者对应了 char str[] = "Hello world." 。那么借用这个方法，我们可以手动定义一个 const char[] 的变量，然后在 C 代码中调用这个变量，即可达到访问被包含文件的目的。

GCC 支持用 __asm__() 来内联汇编代码，那么我们可以这样写

#include <stdio.h>

__asm__(
    ".section .rodata \n"
    ".globl foo_str \n"
    "foo_str:\n"
    ".string \"Hello world\"\n"
    ".byte 0\n"
);

extern const char foo_str[];

int main() {
    puts(foo_str);
    return 0;
}

这样这个程序可以正常输出 “Hello world” ，那把 .string ... 换成 .incbin 就完成了：

__asm__(
    ".section .rodata \n"
    ".globl foo_str \n"
    "foo_str:\n"
    ".incbin \"file\"\n"
    ".byte 0\n"
);

此时运行程序会输出

1
2

$ ./a.out
Hello world from "file"

此时我们的目的就达到了，应该可以收工了？

如果这个代码只在 Linux 平台编译，那应该是可以收工了，但如果这个代码要在 macOS 或者 Windows 平台编译，编译器会报错，因为不同系统上的汇编代码并不完全兼容，我们还需要对它进行一点点修改：

Windows 平台上 .rodata 对应 .rdata "dr"
macOS 平台上 .rodata 对应 __TEXT,__const

此外， macOS 上的编译器生成的汇编代码里符号前面会多一个下划线：

`1`	`const char str[] = "hello world";`

对应的汇编代码是

    .section __TEXT,__const
    .globl _str                    ## @str
_str:
    .asciz "hello world"

那么对应的 __asm__() 内也要把这个下划线加上，否则编译器会报错。

宏+内联汇编

如果代码里只有一处需要打包文件，那么直接手写内联汇编没什么问题；但需要打包的东西多了后再这么做就很麻烦了，于是有人写了一个宏来解决：

#define STR2(x) #x
#define STR(x) STR2(x)

#ifdef _WIN32
#define INCBIN_SECTION ".rdata, \"dr\""
#else
#define INCBIN_SECTION ".rodata"
#endif

// this aligns start address to 16 and terminates byte array with explict 0
// which is not really needed, feel free to change it to whatever you want/need
#define INCBIN(name, file) \
    __asm__(".section " INCBIN_SECTION "\n" \
            ".global incbin_" STR(name) "_start\n" \
            ".balign 16\n" \
            "incbin_" STR(name) "_start:\n" \
            ".incbin \"" file "\"\n" \
            \
            ".global incbin_" STR(name) "_end\n" \
            ".balign 1\n" \
            "incbin_" STR(name) "_end:\n" \
            ".byte 0\n" \
    ); \
    extern __attribute__((aligned(16))) const char incbin_ ## name ## _start[]; \
    extern                              const char incbin_ ## name ## _end[]

INCBIN(foobar, "binary.bin");

但这个宏只能在 Linux 和 Windows 上运行，本人对其做了一点修改，使之能在 macOS 上跑，并且多定义一个表示大小的 _size 变量：

#define STR2(x) #x
#define STR(x) STR2(x)

#ifdef __APPLE__
#define USTR(x) "_" STR(x)
#else
#define USTR(x) STR(x)
#endif

#ifdef _WIN32
#define INCBIN_SECTION ".rdata, \"dr\""
#elif defined __APPLE__
#define INCBIN_SECTION "__TEXT,__const"
#else
#define INCBIN_SECTION ".rodata"
#endif

// this aligns start address to 16 and terminates byte array with explict 0
// which is not really needed, feel free to change it to whatever you want/need
#define INCBIN(prefix, name, file) \
    __asm__(".section " INCBIN_SECTION "\n" \
            ".global " USTR(prefix) "_" STR(name) "_start\n" \
            ".balign 16\n" \
            USTR(prefix) "_" STR(name) "_start:\n" \
            ".incbin \"" file "\"\n" \
            \
            ".global " STR(prefix) "_" STR(name) "_end\n" \
            ".balign 1\n" \
            USTR(prefix) "_" STR(name) "_end:\n" \
            ".byte 0\n" \
            ".balign 16\n" \
            ".global " STR(prefix) "_" STR(name) "_size\n" \
            USTR(prefix) "_" STR(name) "_size:\n" \
            ".long " USTR(prefix) "_" STR(name) "_end" " - "  USTR(prefix) "_" STR(name) "_start \n"\
    ); \
    extern __attribute__((aligned(16))) const char prefix ## _ ## name ## _start[]; \
    extern                              const char prefix ## _ ## name ## _end[]; \
    extern __attribute__((aligned(16))) const long prefix ## _ ## name ## _size

INCBIN(incbin, foobar, "file");
// printf("%s\n", incbin_foobar_start);

对于 C++ 而言，上面的代码几乎可以照抄，唯一需要注意的是 C++ 对符号有 mangling 操作，变量名和 label 不一样，所以需要把 extern const ... 改成 extern "C" const ... 让编译器知道这个变量对应的 label 不需要 mangling ，从而正确找到目标文件里对应的 label 。

Fortran 的处理

Fortran 不能内联汇编，所以上面的代码放到 .F 里是不能用的，我们可以通过 FFI 让 Fortran 间接实现这些操作。

需要注意的是， Fortran 的字符串带长度信息，而 C 字符串则是以 '\0' 来表示结尾，并没有直接标注长度信息，这个不同给 Fortran 和 C 的互操作带来的不小的麻烦……

准备一个 incbin.c 文件，里面用上一节的方法包含想要的文件，并暴露出 file_start 和 file_size 两个变量，准备一个 main.f90 文件，用 iso_c_binding 提供的 bind 来对接刚刚暴露的变量：

module foo
    use iso_c_binding
    implicit none

    integer(kind=c_int), bind(C, name="incbin_foobar_size") :: slen
    character(kind=c_char, len=1024*1024), bind(C, name="incbin_foobar_start") :: cstr
    character(len=:), allocatable :: fstr

    public :: slen, fstr
    private :: cstr

    contains

    subroutine initialize
        integer :: i
        if (allocated(fstr)) return
        allocate(character(len=slen) :: fstr)
        forall(i=1:slen) fstr(i:i) = cstr(i:i)
    end subroutine initialize
end module foo

program main
    use foo
    implicit none

    call initialize
    print '(A)', fstr
end program main

它通过 initialize 函数来把 C 代码中定义的 incbin_foobar_size 转换成 Fortran 里带长度信息的字符串，这个操作产生了一次内存复制，如果你没有内存复制洁癖，这也是可以接受的。

但如果你不想要这多余的内存复制操作，可以把 cstr 里的 len=1024*1024 直接改成 len=<length of file> ，然后可以直接 print '(A)', cstr 也能访问。手动输入文件长度也很麻烦，那不如在 Makefile 里定义一个宏，把文件长度填进去即可：

1
2

FILELEN = $(shell \ls -l incbin.c | awk '{print $$5}')
FFLAGS += -DFILELEN=$(FILELEN)

`1`	`character(kind=c_char, len=FILELEN), bind(C, name="incbin_foobar_start") :: cstr`

然后 print '(A)', cstr 就能直接得到对应文件的信息了。

顺便多说一句，这各写法已经是我能想到最简洁的方法了，本人曾试过其它更优雅的写法，但都无法成功，只能作罢。

小结

以上只是一些把文件打包里程序里的奇技淫巧，本身不值一提，只是被 Fortran 与 C 字符串的互操作恶心到了，不吐不快。其实关于打包文件，有人已经写了比较成熟的库，就叫 incbin ，我大概浏览了一下，里面对多个平台、多个编译器做了适配，甚至对 SIMD 的内存对齐也有考虑，可以说是相当完善，有需要可以直接用。

在 CentOS 7 上使用 Clangd 作为 C/C++ 的 LSP

Sat, 25 Mar 2023 19:22:00 +0800

Table of Contents

最近在 CentOS 7 服务器上写程序时没有 LSP 的帮助，感觉写起来很费劲，于是折腾了一下 clangd 使之能为 coc.nvim 所用。

基本环境要求

Anaconda/Miniconda 可以去各大镜像站下载安装包，然后直接 sh Anaconda_xxx.sh 进行安装。这里推荐使用 miniconda ，因为 Anaconda 内置的包太多，每次 conda install 解析依赖冲突都会耗时 114514 年，而 miniconda 因为内置的包更少，依赖解析起来反倒更快。

Vim 及其插件使用 conda 命令安装 Vim 8.0 或更高的版本

`1`	`conda install -c conda-forge vim`

然后查看 vim 的版本号：

      $ vim --version
      VIM - Vi IMproved 9.0 (2022 Jun 28, compiled Aug 31 2022 01:19:52)
      Included patches: 1-335
      Compiled by conda@065326dfb3d2
      Huge version without GUI.  Features included (+) or not (-):
      +acl               +file_in_path      +mouse_urxvt       -tag_any_white
      ...
      ...

是 9.0 ，说明安装成功。

然后安装 vim-plug 和 coc.nvim ，直接 Follow 官网上的安装教程即可

安装 `clangd`

CentOS 7 的 yum 源里也有 llvm 和 clang 的包，但它们都没有提供 clangd ，那我们只能去自己安装了。

其实如果你使用 coc-clangd 的话，它会帮你下载 clangd 的可执行文件，但网上预编译的 clangd 没有对 CentOS 7 这种老平台适配，运行时会报这个经典错误

`1`	/lib64/libc.so.6: version `GLIBC_2.18' not found (required by clangd)

这是因为 CentOS 7 默认的 glibc 只有 2.17 ，而贸然升级 glibc 又是管理 Linux 服务器的大忌（各种程序会炸），那就只能寻求别的办法了。

所幸 Anaconda 提供了 clangd ，我们只需要执行下面的命令即可

`1`	`conda install -c conda-forge clang clangxx clang-tools`

然后检查一下各个程序的版本

$ clang --version
clang version 14.0.6
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /public/home/xxx/.miniconda/bin

$ clang++ --version
clang version 14.0.6
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /public/home/xxx/.miniconda/bin

$ clangd --version
clangd version 14.0.6
Features: linux
Platform: x86_64-unknown-linux-gnu

写一个 C 的 Hello world ：

#include <stdio.h>

int main(int argc, char* argv[]) {
    puts("Hello world.");
    return 0;
}

看能不能用 Clang 编译

1
2

$ clang main.c && ./a.out
Hello world.

看来是没问题的；那么 C++ 的 Hello world 呢？

#include <iostream>

int main() {
    std::cout << "Hello world." << std::endl;
    return 0;
}

使用 clang++ 编译：

$ clang++ main.cpp
main.cpp:1:10: fatal error: 'iostream' file not found
#include <iostream>
         ^~~~~~~~~~
1 error generated.

这又是一个很经典的错误，它表示 clang++ 找不到头文件 iostream ，解决它的办不是添加 -I/usr/include/... 等参数，而是告诉 clang++ 借用 gcc 工具链内的一些头文件和链接库，具体办法就是使用 --gcc-toolchain 这个参数，官网¹ 上对这个参数的说明中表示

1
2

--gcc-toolchain=<arg>
Specify a directory where Clang can find ‘include’ and ‘lib{,32,64}/gcc{,-cross}/$triple/$version’. Clang will use the GCC installation with the largest version

那就很好办了，直接指定 --gcc-toolchain=/usr 即可：

1
2

$ clang++ --gcc-toolchain=/usr main.cpp && ./a.out
Hello world.

编译运行成功。

此时关于 Clang 的安装就完成了。

配置 `coc.nvim`

coc.nvim 的官网提供了 clangd 的配置模板，直接复制到 ~/.vim/coc-settings.json 里即可

"languageserver": {
  "clangd": {
    "command": "clangd",
    "rootPatterns": ["compile_flags.txt", "compile_commands.json", ".git/", ".hg/"],
    "filetypes": ["c", "cc", "cpp", "c++", "objc", "objcpp"]
  }
}

此时，用 Vim 打开刚才写的 C Hello world main.c 应该已经可以提供补全了，如图所示

接下来配置 C++ 源文件的补全。如果不添加别的参数，那么打开刚刚的 C++ Hello world main.cpp ，应该会出现以下错误这和之前直接用 clang++ 编译时的错误一模一样，之前是通过给 clang++ 加一个参数 --gcc-toolchain=/usr 来解决的，那么一定有方法可以把编译参数传给 clang++ 来让 clangd 正常工作。 clangd 官网上给出的解决方案是在 main.cpp 同目录下写一个配置文件让 clangd 来正确调用相关的程序，有三种格式可供选择：

compile_commands.json

这个就是用 json 的格式把编译时需要的命令和参数记录下来传给 clangd ，它需要把每个文件的编译命令都显式写出来，我想没人会喜欢手写 json ，并且是如此啰嗦的 json ，下面是一个示例²

      [
      {
          "directory": "/public/home/xxx/tests/cxx",
          "arguments": ["/public/home/xxx/.miniconda/bin/clang++", "--gcc-toolchain=/usr", "main.cpp"],
          "file": "file.cc"
      },
      ]

compile_flags.txt

这个文件的格式非常简单，把参数逐行写到这个文件里即可
1 2

--gcc-toolchain=/usr --std=c++11
然后 clangd 就能正常工作了。

.clangd

这个文件格式会稍微复杂一些，官网³上有详细的解释，这里给出一个可用的示例
1 2

CompileFlags: Add: [--gcc-toolchain=/usr]

将上述三个文件中的任意一个放到 main.cpp 的同目录下，用 Vim 打开 main.cpp ， LSP 应该能正常补全了

看起来效果不错，但总要写这些配置文件总让人不爽，倒不是说参数太长，而是连建个 Hello world 都要写个配置文件难免过于麻烦了，而且编译参数在 Makefile 里已经写过一遍，再写一遍岂不很累。有没有办法不用写这些配置，就把参数传给 clang++ ？经过上网冲浪，在 vscode 和 coc-clangd 的配置里有个参数叫 --fallbackFlags ，它表示当 clangd 找不到上面 compile.json 、 compile_flags.txt 和 .clangd 中任意一个时所使用的参数。从 coc-clangd 的源码⁴里得知，这个参数应该被放在 initializationOptions 下面。打开 ~/.vim/coc-settings.json ，加上这个参数：

"languageserver": {
    "clangd": {
        "command": "clangd",
        "rootPatterns": ["compile_flags.txt", "compile_commands.json", ".git/", ".hg/"],
        "filetypes": ["c", "cc", "cpp", "c++", "objc", "objcpp"],
        "initializationOptions": {
            "fallbackFlags":["--gcc-toolchain=/usr"]
        }
    }
}

删掉 compile.json 、 compile_flags.txt 和 .clangd ，然后打开 main.cpp ，补全依然正常工作，大功告成。

当然如果你需要为某个工程写特定的编译参数，那还是老老实实用那三个配置文件吧， initializationOptions 仅限简单场景使用。

利用 Const Generics 实现编译期量纲分析

Sun, 05 Mar 2023 11:59:00 +0800

Table of Contents

开学前折腾了一段时间的 Rust const generics ，也读了一些前人的代码，并自己写出了自己的编译期量纲分析代码，因此吸收总结这一过程所得知识，产生了这篇博文。本文的实现全部代码在这里。

什么是量纲分析

这里浅薄地介绍一下什么是量纲分析。贴一下 Wiki¹ 上关于量纲和量纲分析的定义：

量纲是表示一个物理量由基本量组成的情况。确定若干个基本量后，每个派生量都可以表示为基本量的幂的乘积的形式，引入量纲分析可以进行量纲分析，这既是物理学的基础，又有很多重要的应用。通常一个物理量的量纲是由像质量、长度、时间、电荷量、温度一类的基础量纲结合而成；
量纲分析是指对数学或者物理学中物理量的量纲可以用来分析或检验几个物理量之间的关系。在判断一个由推导获得的方程式或计算结果是否合理时，可以对等号两边的量纲进行化简，从而确认是否一致，这个过程即用到了量纲分析。对于较为复杂的情况，量纲分析也可以用来建立合理的假设，然后用严格的实验加以验证，或用已发展成功的理论来仔细推敲。

由于目前的基本物理量有七个，故在量纲中分别用七个字母表示它们的量纲，分别为：

长度（L）
质量（M）
温度（Θ）
电流（I）
时间（T）
物质的量（N）
发光强度（J）

任何一个物理量 \(A\) 都可以写出下列量纲式： \[ \text{dim} A = L^{\alpha} M^{\beta} \Theta^{\gamma} I^{\delta} T^{\epsilon} N^{\zeta} J^{\eta} \] 如果一个物理量的量纲中所有的指数为 0 ，那么称它为无量纲量，常见的无量纲量有精细结构常数 \(\alpha \approx 1/137\) 、雷诺数 \(\text{Re} = \frac{\rho VL}{\mu} = \frac{VL}{\nu}\) 以及各种比值、概率等。两个物理量量纲一致是它们能够相加减的必要条件，而不是充要条件，比如力矩和能量的量纲都是 \(F \cdot L\) ，但这两个量显然无法相加减。物理量的乘除乘方开方则没有这个限制，直接按照相应的代数运算法则对各个基本量纲处理再化简即可。

值得注意的是，能放在指数和真数位置上的物理量一定是无量纲量。回想一下统计力学中几乎无处不在的 \( \frac{E}{k_{\mathrm{B}} T}\) ，其中分母 \(k_B T\) 的量纲是能量，刚好与分子上 \(E\) 相抵消，导致指数整体是一个无量纲量，进而使得 \( \frac{E}{k_{\mathrm{B}} T}\) 这个整体也是一个无量纲量；又比如在化学反应中常见的公式 \(\Delta G = \Delta G^{\ominus} + RT \ln K\) ，其中化学平衡常数 \(K\) 处于真数的位置，它一定是一个无量纲量。

此时，我们可以大致总结一下量纲分析运算的规则：

物理量的量纲由 7 个基本量纲构成；
具有相同量纲的物理量才能相加减；
物理量在乘除、乘方和开方时基本量纲的指数遵循代数运算法则；
处于指数、真数位置的物理量是无量纲量。

这些规则是我们程序实现量纲分析的参考。

什么是 Const Generics

Const generics 翻译过来即为常量泛型。在涉及 Rust 泛型代码时，如果泛型参数是一个常量值，而不是类型或生命周期参数等，那么这个泛型参数就称为常量泛型参数²。例如下面一段代码就用到了泛型参数

1
2
3

struct Position<T, const N: usize> {    // N 即为常量泛型参数
    pos: [T; N]
}

上面代码中 const N: usize 中的 const 前缀很贴心地告诉你后面的 N 是一个泛型参数，而 : usize 则表明 N 的类型是 usize 。这段代码定义了一个泛型的 struct ，其中包含一个名为 pos 的数组成员，这个数组元素的类型由 T 决定，而长度由常量泛型参数 N 决定。注意，这里面的 T 和 N 都是编译期参数，也就是说它们在编译期就已经确定，由于 Rust 是一门静态语言，所有变量的类型在编译成机器码时都是可以被推导出来的，我们不能用一个程序运行期的变量（比如一个用户输入的值）作为 T 或 N ，这是不被允许，并且编译器也无法做到的。

那么 Rust 为什么要添加 const generics 这个特性呢？其中的原因在 RFC#2000 已经写得很清楚了，简单来说就是 Rust 将 [T; 1] 、 [T; 2] 、 [T;3] ……这样不同长度的数组看做不同的类型，那么在实现一些操作时就会显得很脏，比如早期版本的 Rust 标准库在实现比较两个定长数组是否相等的特质 Eq 时就分别对 [T; 0] 、 [T; 1] 、 [T; 2] 等等的定长数组各自实现，一直到 [T; 32] 。那么如果你有一个长度大于 32 的定长数组需要比较时怎么办？比如这样的代码

// https://godbolt.org/z/zn1TYfaev
fn compare(lhs: &[i32; 33], rhs: &[i32; 33]) -> bool {
    lhs == rhs
}
// error[E0369]: binary operation `==` cannot be applied to type `&[i32; 33]`
//  --> <source>:2:9
//   |
// 2 |     lhs == rhs
//   |     --- ^^ --- &[i32; 33]
//   |     |
//   |     &[i32; 33]
//   |
//   = note: an implementation of `std::cmp::PartialEq` might be missing for `&[i32; 33]`

编译器会直接报错罢工，而如果把两个 33 全部换成 32 则可以正常编译，是不是感觉非常不可思议？当然这个问题在 2021 年 3 月份 const generics 稳定后就已经被解决了。在 Rustc 1.51 以后，你可以对任意长度的 [T; LEN] 运行比较，以及其它相关的操作，再也不用担心编译器摆烂。

除了解决定长数组的相关问题， const generics 还有其它很多有用的地方，比如可以实现编译期的计算（写 C++ 的同学可能已经开始狂喜了，别高兴太早，用 ~~Ruast~~ 的 const generics 来写类似 C++ 的模板元编译期计算会非常地痛苦，建议不要尝试）等。有一个相对关键的点在于，泛型参数只存在于编译期，也就是说在运行期这个参数不存在。这也意味着常量泛型参数自己并不占内存，比如

1
2
3

struct Foo<const N: usize> {
    value: i64,
}

这个结构体的大小用 std::mem::size_of::<Foo<1>>() 求出来是 8 ，正好等于 i64 本身的大小；事实上，不管 N 取多少，甚至 std::mem::size_of::<Foo<114514>>() ，得到的仍然是 8 ，这为编译器的优化提供了可能。

除此之外，当 N 不同时， Foo<N> 被认为是不同的类型。即使你分别为 Foo<N1> 和 Foo<N2> 分别实现了相同的特质（这里以 Eq 为例），那么当你写下 Foo::<N1>::default() == Foo::<N2>::default() 这样的代码时，除非 N1 == N2 否则编译器会报错提醒你：

#[derive(Default, PartialEq, Eq)]
struct Foo<const N: usize> {
    value: i64,
}

fn main() {
    println!("{}", Foo::<0>::default() == Foo::<1>::default());
}
// error[E0308]: mismatched types
//  --> src/main.rs:7:43
//   |
// 7 |     println!("{}", Foo::<0>::default() == Foo::<1>::default());
//   |                                           ^^^^^^^^^^^^^^^^^^^ expected `0`, found `1`
//   |
//   = note: expected struct `Foo<0>`
//              found struct `Foo<1>`

这个特性对于实现编译期量纲分析是至关重要的，可以说如果没有这个特性，编译期的量纲分析就无法实现。

当然，现在稳定版的 const generics 所支持的功能还十分有限，如果想了解关于它的更多信息，可以戳这个链接。

如何使用 Const Generics 实现量纲分析

在阐述如何使用 const generics 实现编译期量纲分析之前，我们先来了解一下运行期量纲分析有啥缺点。

运行期量纲分析

为了描述量纲，我们需要定义一个结构体来储存七个基本量纲的指数，为了方便实现，这里直接取国际单位制：

#[derive(Default, PartialEq, Eq, Clone, Copy)]   // make SiUnit::default() and SiUnit == SiUnit possible
pub struct SiUnit {
      m: i8,    // meter
      s: i8,    // second
     kg: i8,    // kilogram
      c: i8,    // coulomb
     cd: i8,    // candela
    mol: i8,    // mole
      k: i8,    // kelvin
}

impl SiUnit {
    pub fn new() -> Self {
        SiUnit::default()
    }
}

然后这个结构体需要实现加减运算特质，以满足两个物理量乘除时对量纲的运算：

use std::ops::{Add, Sub, Mul, Div};   // required trait for overload of `+` and `-`.

impl Add for SiUnit {
    type Output = Self;     // required associate type
    fn add(self, rhs: Self) -> Self::Output {
        SiUnit {
              m: self.m    + rhs.m,
              s: self.s    + rhs.s,
             kg: self.kg   + rhs.kg,
              c: self.c    + rhs.c,
             cd: self.cd   + rhs.cd,
            mol: self.mol  + rhs.mol,
              k: self.k    + rhs.k,
        }
    }
}

impl Sub for SiUnit {
    type Output = Self;     // required associate type
    fn sub(self, rhs: Self) -> Self::Output {
        ...
    }
}

这样我们就可以直接执行 SiUnit + SiUnit 、 SiUnit - SiUnit 这样的操作了。

为了实现物理量的乘方开方运算，它还需要实现 Mul 和 Div 特质，与实现 Add 和 Sub 特质不同的是， Mul 和 Div 特质里的右操作数 Rhs 都是 i8 类型，而不是 SiUnit 本身，因为乘方开方的指数都是没有量纲的。

use std::ops::{Mul, Div};

impl Mul<i8> for SiUnit {
    type Output = Self;
    fn mul(self, rhs: i8) -> Self::Output {
        SiUnit {
              m: self.m    * rhs,
              s: self.s    * rhs,
             kg: self.kg   * rhs,
              c: self.c    * rhs,
             cd: self.cd   * rhs,
            mol: self.mol  * rhs,
              k: self.k    * rhs,
        }
    }
}

impl Div<i8> for SiUnit {
    type Output = Self;
    fn div(self, rhs: i8) -> Self::Output {
        SiUnit {
            ...
        }
    }
}

此时， SiUnit 可以进行 SiUnit * 2 、 SiUnit / 2 这样的运算了。那么把和一个值打包在一起就组成一个物理量了：

pub struct PhysicalQuantity<T> {
    value: T,
    unit:  SiUnit,
}

然后我们再为它实现各种运算操作，就可以用它代入各种公式求值了。那么这其中有什么问题呢？

它占用的内存太多。用 std::mem::size_of::<PhysicalQuantity<f64>>() 查看一下这个结构体占用的内存，为 16 字节，这说明不参与值运算的 unit 成员就占用了一半的空间；如果对一个 [PhysicalQuantity; len] 这样的数组运算，那么所有元素的 unit 成员就交错分布在真正需要运算的 value 成员中间，这对 CPU 的缓存命中和 SIMD 优化是非常不利的，进而造成可观的性能损失；
PhysicalQuantity 之间没有区分，也就是说 unit 不同的 PhysicalQuantity 被认为是同一个类型，当它们被放在同一个数组等线性表里时，编译器不会报错，而且人工检查也只能在运行时进行；
PhysicalQuantity 在执行加减运算时需要手动检查 unit 是否一致；在执行乘除法时，需要对 unit 运行相应的运算，这些均在运行时进行，并且每个元素操作时都要做，这也会严重降低运行效率。

如此这些缺陷在 const generics 的加持下都可以解决。

利用 const generics 实现编译期的量纲分析

为了让编译器在编译期帮助我们推导量纲，我们可以利用 const generics ，把量纲信息放在泛型参数里，如下所示：

#![feature(adt_const_params)]

use num::Num;

#[derive(PartialEq)]
pub struct PhysicalQuantity<T, const U: SiUnit>
where T: Num
{
    value: T,
}

impl<T, const U: SiUnit> PhysicalQuantity<T, U>
where T: Num,
{
    pub fn new(value: T) -> Self {
        Self { value }
    }
}

需要注意的是，在现在 Rustc 最新稳定版(1.67)里，只能支持整数、 bool 以及 char 作为 const generic params ，想要放结构体进去需要切换到 nightly 频道，并在代码开头加上 #![feature(adt_const_params)] 来开启 adt_const_params 这个 feature ，从而支持把 SiUnit 放到泛型参数里。此时，运行 std::mem::size_of<PhysicalQuantity<f64, SiUnit::default()>>() ，输出为 8 ，说明没有多余的空间占用，第一个问题得以解决。

为了方便起见，我们定义一些类型别名

const METER: SiUnit = SiUnit {
      m: 1,
      s: 0,
     kg: 0,
      c: 0,
     cd: 0,
    mol: 0,
      k: 0,
};
type Meter<T> = PhysicalQuantity<T, METER>;

const METER_PER_SEC: SiUnit = SiUnit {
      m:  1,
      s: -1,
     kg:  0,
      c:  0,
     cd:  0,
    mol:  0,
      k:  0,
};
type Mps<T> = PhysicalQuantity<T, METER_PER_SEC>;

然后比较一个两个量纲不同的量，看会有什么反应

let a = Meter::<f64> { value: 1.0 };
let b = Mps::<f64> {value: 2.0};
assert_ne!(a, b);   // cannot compile
// error[E0308]: mismatched types
//   --> src/main.rs:54:5
//    |
// 54 |     assert_ne!(a, b);   // cannot compile
//    |     ^^^^^^^^^^^^^^^^ expected `SiUnit { m: 1, s: 0, kg: 0, c: 0, cd: 0, mol: 0, k: 0 }`, found `SiUnit { m: 1, s: -1, kg: 0, c: 0, cd: 0, mol: 0, k: 0 }`
//    |
//    = note: expected struct `PhysicalQuantity<_, SiUnit { m: 1, s: 0, kg: 0, c: 0, cd: 0, mol: 0, k: 0 }>`
//               found struct `PhysicalQuantity<_, SiUnit { m: 1, s: -1, kg: 0, c: 0, cd: 0, mol: 0, k: 0 }>`
//    = note: this error originates in the macro `assert_ne` (in Nightly builds, run with -Z macro-backtrace for more info)

// For more information about this error, try `rustc --explain E0308`.

此时，编译器拒绝编译，并给出了错误信息，其中明确说明参数 b 存在类型错误，从而避免用户强行将两者放在一起比较。这也表明只要量纲一致，那么类型肯定一致；反之如果量纲不一致，类型也一定不同，这可以将用户的编码错误提前到编译期暴露出来，第二个问题得以解决。

以上只是一个示例，下面我们来为 PhysicalQuantity 实现更多功能。

`SiUnit` 的编译期运算

首先，我们需要在编译期对 SiUnit 进行运算，之前的 impl Add for SiUnit { ... } 是为 SiUnit 实现一个函数，然而这个函数只能在运行期跑，如何解决？这里就要用到 nightly 的另一个不稳定特性 const_trait_impl ，然后 impl const Add for SiUnit 就可以了：

#![feature(const_trait_impl)]

impl const Add for SiUnit { ... }
impl const Sub for SiUnit { ... }
impl const Mul<i8> for SiUnit { ... }
impl const Div<i8> for SiUnit { ... }

`PhysicalQuantity` 的加减法运算

然后我们来考虑为 PhysicalQuantity 实现各种运算。我们先为它实现最为简单的加减运算，由于加减运算的两个操作数量纲一致，类型肯定相同，那么实现加减法就不需要对 SiUnit 进行运算：

impl<T, const U: SiUnit> Add for PhysicalQuantity<T, U>
where T: Num,
{
    type Output = PhysicalQuantity<T, U>;
    fn add(self, rhs: Self) -> Self::Output {
        Self::Output {
            value: self.value + rhs.value
        }
    }
}

impl<T, const U: SiUnit> Sub for PhysicalQuantity<T, U>
where T: Num,
{
    type Output = PhysicalQuantity<T, U>;
    fn sub(self, rhs: Self) -> Self::Output {
        Self::Output {
            value: self.value - rhs.value
        }
    }
}

`PhysicalQuantity` 的乘除法运算

而 PhysicalQuantity 的乘除法不要求左右操作数量纲一致，并且产生的结果可能有着第三种量纲，因此在实现乘除法的特质时会稍微麻烦一点，也会用到本文提到的第三个不稳定特性 generic_const_exprs ，它支持在 const generic params 里写表达式，而这个表达式则需要用花括号包起来，比如像 PhysicalQuantity<T, {U+V}> 这样：

#![feature(generic_const_exprs)]

impl<T, const U: SiUnit, const V: SiUnit> Mul<PhysicalQuantity<T, V>> for PhysicalQuantity<T, U>
where
    T: Num,
    PhysicalQuantity<T, {U+V}>:,    // generic_const_exprs used
{
    type Output = PhysicalQuantity<T, {U+V}>;
    fn mul(self, rhs: PhysicalQuantity<T, V>) -> Self::Output {
        Self::Output {
            value: self.value * rhs.value
        }
    }
}


impl<T, const U: SiUnit, const V: SiUnit> Div<PhysicalQuantity<T, V>> for PhysicalQuantity<T, U>
where
    T: Num,
    PhysicalQuantity<T, {U-V}>:,    // generic_const_exprs used
{
    type Output = PhysicalQuantity<T, {U-V}>;
    fn div(self, rhs: PhysicalQuantity<T, V>) -> Self::Output {
        Self::Output {
            value: self.value / rhs.value
        }
    }
}

上面的代码的每个特质的实现中，除了 T 之外，一共有三个泛型，分别是 U 、 V 和 U±V ，而在 impl<> 只能写 U 和 V 这两个参数（ U 属于 PhysicalQuantity ， V 存在于 Mul<Rhs> 中的 Rhs 内），那么 U±V 就只能放在 where 里进行约束了。

那么，为什么不直接 where {U±V}:, 这样来约束呢，那是因为现在编译器还不够强，不支持这样写，如果 U 和 V 是 usize 类型，官方支持 where [(); {U±V}]:, 这样来进行约束。但不幸的是，这里的 U 和 V 是 SiUnit 类型，除非你为它实现了转换到 usize 的特质，然后写 where [(); {U±V}.into::<usize>()]:, 这样的约束条件。除了这个选择，我们可以直接约束 PhysicalQuantity<T, {U±V}> 这个类型本身，幸运的是， rustc 确实接受这样的写法，谢天谢地。

顺便吐槽一下， generic_const_exprs 所支持的表达式十分有限，甚至当 U 和 V 为 usize 时， {U+V} 和 {V+U} 被认为是不等价的，这也意味着我们在写表达式时需要十分小心表达式的顺序，如果写错的话，编译器吐出来的东西可能会非常难看……

言归正传，经过上面的实现后，我们可以对不同量纲的物理量进行乘除运算了，比如：

let a = Meter::<f64> { value: 1.0 };
let b = Mps::<f64> { value: 2.0 };
let c = a / b;
println!("type: {}, value: {}", std::any::type_name_of_val(&c), c.value);
// type: playground::PhysicalQuantity<f64, playground::SiUnit { m: 0, s: 1, kg: 0, c: 0, cd: 0, mol: 0, k: 0 }>, value: 0.5

在打印出 c 的类型后，它的量纲确实是时间，说明我们的实现是正确的。

`PhysicalQuantity` 的乘方开方运算

到现在为止，我们已经为 PhysicalQuantity<T, U> 实现了四则运算。相比于前面的实现，乘方、开方的运算要更麻烦一些，因为返回值的量纲取决于指数，等于说返回的类型取决于指数，这要求我们必须把指数放在 const generics param 的位置上，否则存在于运行期的指数无论如何也无法让编译器在编译期推导出返回类型。特质 num::pow::Pow 定义了 .pow() 函数，但这个函数的签名中指数存在于第二个函数参数的位置上，而不是常量泛型参数的位置上，因此不能使用；尽管如此，我们仍可以照猫画虎，仿照 num::pow::Pow 来自己定义一个特质 Power ：

pub trait PowerI<const power: i8> {
    type Output;    // 关联类型
    fn powi(self) -> Self::Output;
}

然后为 PhysicalQuantity 实现它

impl<T, const U: SiUnit, const power: i8> PowerI<power> for PhysicalQuantity<T, U>
where
    T: Num + Pow<i8, Output = T>,
    PhysicalQuantity<T, {U*power}>:,
{
    type Output = PhysicalQuantity<T, {U*power}>;
    fn powi(self) -> Self::Output {
        Self::Output {
            value: self.value.pow(power)
        }
    }
}

最后，我们应该怎样调用它呢？经过与 rustc 的搏斗，我发现主要有以下两种写法：

let f2 = <Meter<f64> as PowerI<2>>::powi(f);
let f2 = PowerI::<2>::powi(f);

第 1 种写法看着就令人头疼，第 2 种写法稍微好一些，但也只是五十步笑百步。造成写法如此难看的原因是指数 power 被放在了 trait 的泛型参数里，而不是 fn powi<power>(self) ... 这个函数的泛型参数里。但是，如果将 power 写在 fn powi() 里，那么当你在实现时不得不面对 E0207 错误：

pub trait PowerI {
    type Output;
    fn powi<const power: i8>(self) -> Self::Output;
}

impl<T, const U: SiUnit, const power: i8> PowerI for PhysicalQuantity<T, U>
where
    T: Num + Pow<i8, Output = T>,
    PhysicalQuantity<T, {U*power}>:,
{
    type Output = PhysicalQuantity<T, {U*power}>;
    fn powi(self) -> Self::Output
    {
        Self::Output {
            value: self.value.pow(power)
        }
    }
}
//     |
// 182 | impl<T, const U: SiUnit, const power: i8> PowerI for PhysicalQuantity<T, U>
//     |                          ^^^^^^^^^^^^^^^ unconstrained const parameter
//     |
//     = note: expressions using a const parameter must map each value to a distinct output value
//     = note: proving the result of expressions other than the parameter are unique is not supported

这个报错告诉我们常量泛型参数 power 必须出现在 impl<...> Trait<...> for Object<...> 的后两个尖括号内，或者直接出现 where 约束的从句里，以表达式的形式出现则不被接受。上面代码里就是因为 where PhysicalQuantity<T, {U*power}> 中 power 是以表达式的形式出现而被拒绝编译，以笔者水平，看来这条路是走不通了。

那有没有简单、直接点的实现，让我们可以 f.powi::<power>() 呢？当然有的，直接 impl ，给 PhysicalQuantity 添加方法即可：

impl<T, const U: SiUnit> PhysicalQuantity<T, U>
where
    T: Num + Pow<i8, Output = T>,
{
    fn powi<const power: i8>(self) -> PhysicalQuantity<T, {U*power}> {
        PhysicalQuantity::<T, {U*power}> {
            value: self.value.pow(power)
        }
    }
}

这样就能使用 let f2 = f.powi::<2>() 来求得 f 的平方了，看起来这样的实现既简单，效果也好 ~~所谓大道至简，也即是如此吧2333~~ 。至于开方，它和乘方的实现几乎一致，这里限制 T 为浮点数类型，为了使返回类型 T 与输入类型 T 一致：

impl<T, const U: SiUnit> PhysicalQuantity<T, U>
where
    T: Float + From<f64>,
{
    fn nth_root<const root: i8>(self) -> PhysicalQuantity<T, {U/root}> {
        PhysicalQuantity::<T, {U/root}> {
            value: self.value.powf((1.0f64 / root as f64).into())
        }
    }
}

然后就可以 f.nth_root::<3>() 来求 f 的立方根了。

无量纲数及常系数的特殊处理

有时公式中还会出现无量纲系数直接相乘的情况，比如 \(\frac{1}{4\pi \epsilon}\) ，这时如果把 \(4\pi\) 手动写成 PhysicalQuantity::<T, U>::new(4.0 * pi) 的形式，未免过于冗长。这种情况下，我们需要为直接数 T 实现到无量纲 PhysicalQuantity 类型的转换特质：

const DIMENSIONLESS: SiUnit = SiUnit {
      m: 0,
      s: 0,
     kg: 0,
      c: 0,
     cd: 0,
    mol: 0,
      k: 0,
};
type Dimensionless<T> = PhysicalQuantity<T, DIMENSIONLESS>;

impl<T> From<T> for Dimensionless<T>
where T: Num,
{
    fn from(value: T) -> Dimensionless<T> {
        Dimensionless::<T> { value }
    }
}

然后就可以这样写了：

1
2
3

let d = c * 4.0.into();
println!("type: {}, value: {}", std::any::type_name_of_val(&d), d.value);
// type: playground::PhysicalQuantity<f64, playground::SiUnit { m: 0, s: 1, kg: 0, c: 0, cd: 0, mol: 0, k: 0 }>, value: 2

注意，这里还有一个坑， let d = 4.0.into() * c 是无法编译的，因为 a * b 运算具体调用哪个函数首先取决于 a 的类型，编译器会查找左操作数类型与 a 一致的函数，然后在其中查找右操作数类型与 b 一致的函数 mul(type_a, type_b) ，最后调用 mul() 。如果 4.0.into() 写在 * 的左边，由于 4.0.into() 得到并不是一个固定的类型，这个类型取决于上下文，那么查找相应 mul 函数的第一步就无法完成，编译器自然会报错。如何解决呢？我们可以指定 .into() 得到的类型： <f64 as Into<Dimensionless<f64>>>::into(4.0) 或者 Dimensionless::<f64>::from(4.0) ，但这两种写法都太麻烦了，不如直接把 4.0.into() 写在右面，一样可以编译通过。

尽管如此， 4.0.into() 这种写法依然看起来很糟糕，为什么不能直接实现 4.0 * c 这样的写法呢？因为要支持这样的写法意味着我们需要对四则运算分别再实现一遍，像 impl<T> Op<T> for Dimensionless<T> where T: Num 这样；而且由于孤儿规则的存在，编译器也不允许我们 impl<T> Op<Dimensionless<T>> for T where T: Num ，所以只能作罢。出于复用 PhysicalQuantity 之间已经实现的运算的目的，不如把无量纲系数转换为 Dimensionless<T> ，再利用已有的函数去实现各种运算，何乐而不为呢（）。至于 4.0.into() 这种看起来很丑的写法，这是 Ruast 的一大特色，不得不品尝，连标准库的文档里都充斥着 1.0_f64.sqrt() 这种一样“很丑”的写法，习惯就好啦，你多看几眼就不觉得丑啦 ~~（这就是 Ruast 带给我们的自信）~~ 。

对于一般的数，乘法运算是对易的，但除法却不是。当除数是无量纲数时，我们可以使用 c / 4.0.into() ；但当被除数是无量纲数时，我们只能 Dimensionless::from(4.0f64) / c 这样来处理了。

对于 \(e^{c}\) 和 \(\ln{c}\) 等限制输入为无量纲数的函数，我们可以通过只为 Dimensionless 类型实现相关函数来实现：

impl<T> Dimensionless<T>
where T: Float,
{
    pub fn exp(self) -> Self {
        Self { value: self.value.exp() }
    }

    pub fn ln(self) -> Self {
        Self { value: self.value.ln() }
    }
}

这样，即使用户传入了一个非无量纲数，编译器也会在编译期把这种代码拒之门外。

至此，我们已经为 PhysicalQuantity 实现了基础的运算操作，现在已经可以用它去做一些简单的推导了，并且推导的过程完全是编译期完成的，并且只要能编译成功，就能保证结果的量纲和单位正确。

其它实现

其实很早就有编译期量纲分析的实现了，它们没有用到 const generics 这个特性，而是直接使用 typenum 这个库提供的 Integer 特质，其定义如下

pub trait Integer: Sealed + Copy + Default + 'static {
    const I8: i8;
    const I16: i16;
    const I32: i32;
    const I64: i64;
    const ISIZE: isize;

    fn to_i8() -> i8;
    fn to_i16() -> i16;
    fn to_i32() -> i32;
    fn to_i64() -> i64;
    fn to_isize() -> isize;
}

这个特质作为泛型约束出现，那么它所约束的泛型参数就相当于本文实现中 const unit: SiUnit 内的的成员，然后分别定义了一系列 P1 、 P2 、 N1 …… 等等类型，对这些类型实现 Integer 特质，使用时调用 .to_i8() 等函数则返回 1 、 2 、 -1 等等整数，从而模拟 const generics 内的整数，由于 P1 等本质还是类型，所以它不受 const generics 里弱鸡表达式的限制，当然作者为了实现类型之间的运算也是花了很大的功夫，这里就不谈了（其实是没读懂）。比较完善的量纲分析库，我找到的有两个，分别是 dimensioned 和 uom ，其中 dimensioned 的作者也是 typenum 的作者， crates.io 上统计 typenum 的下载量将近八千万，而 dimensioned 也就三万不到，对于作者来说 dimensioned 只是顺手一写的小项目了，即便如此，它的提供了丰富的内置单位和转换操作，足够一般使用。

除了使用 typenum 库的实现，还有用 const generics 实现的库 const_unit_poc ，这是利用 const generics 实现量纲分析的一个 proof of concept ，足够简短，代码也好读，本文就是参考了它的实现。

总结

本文分别实现了运行期的量纲分析和借助 const genreics 实现的编译期量纲分析，着重后者了后者的优势，以及实现上的细节。在使用 const generics 时，依次用到了三个不稳定特性： adt_const_params （让 const generics 支持自定义的 SiUnit 结构体）， const_trait_impl （为 SiUnit 实现编译期的四则运算）和 generic_const_exprs （允许在 const generic params 内写表达式）。这些不稳定特性现在只能临时使用，将来可能会有语法、行为上的变化，因此本文的实现不保证在未来依然可用。在实现的同时，我们也发现了一些 Rust 不那么优雅的地方，比如冗长的 <f64 as Into<Dimensionless<f64>>>::into(4.0) 表达式、对孤儿规则的妥协、 generic_const_exprs 对表达式极为有限的支持等等。不过相比起 C++ 标准的更新速度， Rust 的标准库更新速度还是可以期待的。

本文实现的全部代码在这里 ³。

还有几篇博文对本人帮助很大：

zqp-cn 大佬的针对常量泛型参数的分类实现；
Rust 官方的 Const generics MVP hits beta! ；
Rust 官方的 Splitting the const generics features ；
Rust 中文社区 2021 年的Rust AEAD benchmark 与 Const generics 。

说来编译期的量纲分析其实在 1995 年就被 John J. Barton 和 Lee R. Nackman⁴ 使用 C++ 的模板元编程所实现， C++ 大师 Scott Meyers 也曾专门写了一篇文章阐述如何使用 C++ template 实现量纲分析⁵ 。本人其实也是受这个实现所启发，进而产生了用 Rust 的泛型系统重新实现一下这个功能的想法，进而稍微读了些前人的实现，之后便有了这篇文章。不得不感叹，读别人的代码和自己写完全是两种感觉，有些坑只有自己踩了才会知道，也才能明白有些代码写得拐弯抹角是为了解决啥问题，有啥优势等等。

超长假期学到的一点点东西总算记录了下来，希望不会那么快地忘掉。现在已经开学一两周了，接下来的一两年可能才是艰难险阻的开始，祈祷好运吧……

https://en.wikipedia.org/wiki/Dimensional_analysis ↩︎
https://blog.rust-lang.org/2021/02/26/const-generics-mvp-beta.html ↩︎
https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=4807be24f1e6493bcc5c7cb86457439c ↩︎
John J. Barton 与 Lee R. Nackman 的书 https://www.amazon.com/Scientific-Engineering-Introduction-Advanced-Techniques/dp/0201533936 ↩︎
Scott Meyers 的文章 https://se.inf.ethz.ch/~meyer/publications/OTHERS/scott_meyers/dimensions.pdf ↩︎

简易 DFT 玩具

Sun, 14 Aug 2022 22:13:00 +0800

Table of Contents

一直在用别人写好的 DFT 软件，对软件的运行过程略有兴趣，查阅资料弄懂了一些运行原理并参考了前人的程序后，这次我们来自己写一个 DFT 的玩具～

首先感谢一个 GitHub 上的仓库，为本文的代码提供了参考¹。

理论基础

我们的目标是求解 Kohn-Sham 方程。

对于 Kohn-Sham 方程，系统的能量包含下面几个部分

\[ E[\rho] = T_s[\rho] + \int d\mathbf r v_\text{ext}(\mathbf r) \rho(\mathbf r) + E_\text{Ha} [\rho] + E_\text{xc}[\rho] \]

其中 \(T_s\) 是 Kohm-Sham 动能项，它的表达形式为

\[ T_s[\rho] = \sum_{i=1}^{N} \int d\mathbf r \varphi^*(\mathbf r) \left( -\frac{\hbar^2}{2m} \nabla^2 \right) \varphi_i( r) \]

\(v_\text{ext}(\mathbf r)\) 是外场作用在系统所有电子上的势能，这里“外”是指除所研究电子以外，电子与原子核的相互作用也算在这一项内；

\(E_\text{H}[\rho]\) 为 Hartree 能，也就是电子-电子的库仑相互作用项

\[ E_\text{H}[\rho] = \frac{e^2}{8\pi\epsilon} \int d\mathbf r \int d\mathbf{r'} \frac{\rho(\mathbf r) \rho(\mathbf {r'})}{|\mathbf r - \mathbf{r'}|} \]

\(E_\text{xc}[\rho]\) 是交换关联能，这里为了简便处理，只使用 LDA 近似处理交换项，忽略关联项。在 LDA 近似下

\[ E_\text{x}^\text{LDA}[\rho] = -\frac 34 (\frac 3\pi)^{1/3} \int \rho^{4/3} d \mathbf r \]

上面式子中 \(\rho\) 代表系统的电子密度，它是通过下面方式计算得到：令一系列正交归一的占据态电子轨道为 \(\varphi_i\)，则体系的电子密度为 \[ \rho(\mathbf r) = \sum_i^N |\varphi_i(\mathbf r)|^2 \]

上面的式子表示的都是能量，现在将它们对应到 Kohn-Sham 方程的 Hamiltonian 中

\[ \hat{H}_\text{KS} \Psi = E_\text{KS} \Psi \]

显然动能算符是 \(-\frac{\hbar^2}{2m}\nabla^2\)
外场作用算符为 \(v_\text{ext}(\mathbf r) = \frac{\delta \int d\mathbf r v_\text{ext}(\mathbf r) \rho(\mathbf r)}{\delta \rho}\)
Hartree 作用算符为 \(v_\text{Ha}(\mathbf r) = \frac{\delta E_\text{Ha}[\rho]}{\delta \rho} = \frac{e^2 \Delta V}{4\pi \epsilon} \int\frac{\rho(\mathbf r')}{\sqrt{(\mathbf r - \mathbf r')^2}} d\mathbf r'\)
交换项算符为 \(v_\text{x}(\mathbf r) = \frac{\delta E_\text{x}[\rho]}{\delta \rho} = -(\frac 3\pi)^{1/3} \rho^{1/3}\)

此时 KS 方程和 Hamiltonian 可以展开为

\[\begin{aligned} \hat{H}_\text{KS} &={} -\frac{\hbar^2}{2m}\nabla^2 + v(\mathbf r) \\
&={} -\frac{\hbar^2}{2m}\nabla^2 + v_\text{ext}(\mathbf r) + v_\text{Ha}(\mathbf r) + v_\text{x}(\mathbf r) \\
&={} -\frac{\hbar^2}{2m}\nabla^2 + v_\text{ext}(\mathbf r) + \frac{e^2}{4\pi \epsilon} \int\frac{\rho(\mathbf r')}{\sqrt{(\mathbf r - \mathbf r')^2}} d\mathbf r' -(\frac 3\pi)^{1/3} \rho^{1/3} \end{aligned}\]

将 KS 方程的 Hamiltonian 写成矩阵形式，并对角化，即可得到 KS 轨道 \(\varphi_i\) 和它们对应的能量 \(E_i\) 。

程序实现

为方便起见，这里依然使用 Julia 来实现，请确保机器上的 Julia 已经装上了 Arpack 和 Plots 库。

using LinearAlgebra
using Arpack
using Printf
using PlotlyJS

同时既然是玩具，这里就在一维的空间里计算电子的波函数。这里用到的大部分基础知识在上篇文章《使用数值方法求解单电子 Schrodinger 方程》里都能找到（尤其是一维势箱模型系统的求解部分），因此下面的介绍会有所简化。

这里在 \([-5, 5]\) 之间均匀取 200 个格点来表示整个系统所在的空间。

1
2

ngrid = 200
x = LinRange(-5, 5, ngrid)

\(\nabla^2\) 的矩阵表示

这个算符的矩阵表示在上一篇博客里已经讲过了，这里不再赘述:

\[ \frac{d^2}{dx^2} = \frac{1}{\Delta x^2} \begin{bmatrix} -2 & 1 & & & \newline 1 & -2 & 1 & & \newline & 1 & -2 & \ddots & \newline & & \ddots & \ddots & 1 \newline & & & 1 & -2 \end{bmatrix} \]

写成代码的形式即为

1
2

Δx = x[2] - x[1]
∇² = Tridiagonal(ones(ngrid-1), -2*ones(ngrid), ones(ngrid-1)) ./ (2*Δx)

势能的表示

一般情况下， Hamiltonian 里势能部分的贡献直接体现在对角线上，这里只给出一维形式的势能函数，然后会在所有势能计算好后一并加到 Hamiltonian 里。除此之外，由于取了模型势，电子质量和一些物理常数就直接取为 1 ，比如 \(\frac{e^2}{8\pi\epsilon}\) 和 \(\frac{\hbar^2}{2m_e}\) 等。

外场势能 \(v_\text{ext}(\mathbf r)\)

这里我们选择三个外场模型：无相互作用系统、无限深势阱系统和谐振子系统。

一维势箱系统

在没有周期性边界条件的情况下， \(v_\text{ext}(x) = 0\)

无限深势阱系统

这里的“无限深”也等价于周围的墙壁无限高，即 \[ v_\text{ext}(x) = \begin{cases} \infty & x < -d \\
0 & -d \le x \le d \\
\infty & x > d \end{cases} \] 其中 \(d\) 就是中间势阱宽度，程序中取为 2 。由于程序中无法直接表示值 \(\infty\) ，因此使用一个非常大的正实数来代替，这里取 \(1.0\times 10^10\) 这个值。
1 2

V_well = fill(1e10, ngrid) @. V_well[-2 <= x <= 2] = 0

谐振子系统

谐振子系统的势能是一条抛物线 \[ v_\text{ext}(x) = kx^2 \]

出于简化的目的，这里 \(k\) 直接取为 1 。
1

V_harm = x.^2
以上三种势能函数画出来如下图所示：

电子密度 \(\rho(\mathbf r)\)

Kohn-Sham 方程中包含电子之间库仑相互作用项（也称作 Hartree 项），和交换关联项，而这两者都是电子密度的泛函，因此需要计算电子密度函数 \(\rho(\mathbf r)\) ：

首先应保证每个电子的波函数是正交归一的

\[ \langle \phi_i | \phi_i \rangle = 1 \]

然后电子密度函数为

\[ \rho(x) = \sum_n f_n |\phi(x)|^2 \]

其中 \(f_n\) 表示第 \(n\) 个能级上的电子占据数，本文的体系目前暂不考虑电子的自旋，故 \(f_n\) 的最大值可达到 2 。

根据上面公式，可以写出下面的代码

function get_density(fn::Vector{Float64}, ψ::Matrix{Float64}, Δx::Float64) ::Vector{Float64}
    # fn 是长度为 nlevel 的向量，表示电子的占据数函数
    # ψ 是一个 ngrid x nlevel 的矩阵

    # 首先来归一化波函数
    norms = sum(ψ.^2, dims=1) * Δx
    ψ ./= sqrt.(norms)

    # 求电子密度函数
    ρ = sum(ψ.^2 .* fn', dims=2)
    ρ = dropdims(ρ; dims=2)

    return ρ
end

我们求解不包含库仑势和交换关联势的 Schrodinger 方程后，求得波函数和电子密度如下图所示

库仑势 \(v_\text{Ha}(\mathbf r)\)

库仑势的公式为：

\[ v_\text{Ha}(x) = \frac{e^2 \Delta x}{4\pi \epsilon} \int\frac{\rho(x')}{\sqrt{(x - x')^2}} dx' \]

在程序实现时，限于积分精度和除零的问题，分母中的 \(\sqrt{(x - x')^2}\) 需要加上一个小量 \(\varepsilon\) 避免除零的出现

\[ v_\text{Ha} = \int \frac{n_j \Delta x}{\sqrt{(x - x')^2 + \varepsilon}} dx' \]

function get_hartree(ρ::Vector{Float64}, x::Vector{Float64}; eps=1e-1) ::Tuple{Float64, Vector{Float64}}
    Δx = x[2] - x[1]
    energy = sum((ρ * ρ' .* Δx^2) ./ sqrt.((x' .- x).^2 .+ eps)) / 2
    potential = collect(Iterators.flatten((sum(ρ' .* Δx ./ sqrt.((x' .- x).^2 .+ eps), dims=2))))
    return (energy, potential)
end

交换关联势

首先忽略关联势，使用 LDA 近似，得到交换势为

\[ v_\text{x}^\text{LDA}[\rho] = -\sqrt[3]{3\rho / \pi} \]

那么使用代码表示出来就很简单了：

function get_exchange(ρ::Vector{Float64}, Δx::Float64) ::Tuple{Float64, Vector{Float64}}
    energy = -3.0/4.0 * cbrt(3.0/π) * sum(ρ.^(4.0/3.0)) * Δx
    potential = -cbrt(3.0/π) .* (cbrt.(ρ))
    return (energy, potential)
end

Hamiltonian 的构造

上面说到 Hamiltonian 里势能的部分体现在对角线上

\[\hat{H} = \frac{1}{(\Delta x)^2} \begin{bmatrix} -2 & 1 & & & \newline 1 & -2 & 1 & & \newline & 1 & -2 & \ddots & \newline & & \ddots & \ddots & 1 \newline & & & 1 & -2 \end{bmatrix} + \begin{bmatrix} V_1 & & & \newline & V_2 & & \newline & & \ddots & \newline & & & V_n \end{bmatrix} \]

用代码写出来

function get_hamiltonian(x::Vector{Float64}, ρ::Vector{Float64},
                         v_ext::Vector{Float64}) ::Matrix{Float64}
    Δx = x[2] - x[1]
    ex_energy, ex_potential = get_exchange(ρ, Δx)
    ha_energy, ha_potential = get_hartree(ρ, x)
    ∇² = Tridiagonal(ones(ngrid-1), -2*ones(ngrid), ones(ngrid-1)) ./ (Δx^2)

    # Hamiltonian
    H = -∇²./2 + Diagonal(ex_potential .+ ha_potential .+ v_ext)

    return H
end

对这个 Hamiltonian 对角化，可以得到一系列波函数 \(\phi_i(x)\) 。

`1`	`E, ψ = eigs(H, nev=nlevel, which=:LM, sigma=0) # 这个函数需要 using Arpack`

KS 方程的迭代求解

电子密度 \(\rho(x)\) 依赖于波函数 \(\phi_i(x)\) ，而求解 \(\phi_i(x)\) 所用的 Hamiltonian 又反过来依赖于 \(\rho(x)\) ，这意味着我们不能一次性求得正确的波函数 \(\phi_i(x)\) ，因此我们需要用迭代的方法来求解：

先猜一个初始电荷密度 \(\rho(x)\) ；
用 \(\rho(x)\) 构造 Hartree 势和交换关联势，然后构造 Hamiltonian ；
对角化 Hamiltonian 求得本征值 \(E_i\) 和波函数 \(\phi_i(x)\) ；
判断此次求得本征值 \(E_i\) 与上一次结果相差是否足够小，如果是，则停止计算，否则进入第 5 步；
使用波函数 \(\phi_i(x)\) 构造电子密度 \(\rho(x)\) ，并返回第 2 步。

上面的过程也叫做自洽迭代(self-consistency loop)。

到这一步，我们把所有代码整合起来运行一下，便能得到一个简易的 DFT 玩具

#!/usr/bin/env julia

using LinearAlgebra
using Arpack
using Formatting
using Plots

# Some functions
function get_density(fn::Vector{Float64}, ψ::Matrix{Float64}, Δx::Float64) ::Vector{Float64}
    # fn 是长度为 nlevel 的向量，表示电子的占据数函数
    # ψ 是一个 ngrid x nlevel 的矩阵

    # 首先来归一化波函数
    norms = sum(ψ.^2, dims=1) * Δx
    ψ ./= sqrt.(norms)

    # 求电子密度函数
    ρ = sum(ψ.^2 .* fn', dims=2)
    ρ = dropdims(ρ; dims=2)

    return ρ
end

function get_hartree(ρ::Vector{Float64}, x::Vector{Float64}; eps=1e-1) ::Tuple{Float64, Vector{Float64}}
    Δx = x[2] - x[1]
    energy = sum((ρ * ρ' .* Δx^2) ./ sqrt.((x' .- x).^2 .+ eps)) / 2
    potential = collect(Iterators.flatten((sum(ρ' .* Δx ./ sqrt.((x' .- x).^2 .+ eps), dims=2))))
    return (energy, potential)
end

function get_exchange(ρ::Vector{Float64}, Δx::Float64) ::Tuple{Float64, Vector{Float64}}
    energy = -3.0/4.0 * cbrt(3.0/π) * sum(ρ.^(4.0/3.0)) * Δx
    potential = -cbrt(3.0/π) .* (cbrt.(ρ))
    return (energy, potential)
end

function get_hamiltonian(x::Vector{Float64}, ρ::Vector{Float64},
                         v_ext::Vector{Float64}) ::Matrix{Float64}
    Δx = x[2] - x[1]
    ex_energy, ex_potential = get_exchange(ρ, Δx)
    ha_energy, ha_potential = get_hartree(ρ, x)
    ∇² = Tridiagonal(ones(ngrid-1), -2*ones(ngrid), ones(ngrid-1)) ./ (Δx^2)

    # Hamiltonian
    H = -∇²./2 + Diagonal(ex_potential .+ ha_potential .+ v_ext)

    return H
end

if abspath(PROGRAM_FILE) == @__FILE__
    ngrid = 200
    nlevel = 20
    nelect = 17

    x = collect(LinRange(-5, 5, ngrid))
    Δx = x[2] - x[1]
    ∇² = Tridiagonal(ones(ngrid-1), -2*ones(ngrid), ones(ngrid-1)) ./ (Δx^2)

    # V_ext
    V_empty = zeros(ngrid)
    V_well = fill(1e10, ngrid); @. V_well[-2 <= x <= 2] = 0;
    V_harm = x.^2

    # construct fn
    fn = zeros(nlevel)
    fn[1:(nelect÷2)] .= 2
    if 1 == nelect % 2
        fn[nelect÷2+1] = 1
    end

    max_iter = 1000
    E_threshold = 1E-5

    log0 = Dict("E" => [Inf], "ΔE" => [Inf])  # Use `log0` instead of `log` to avoid confict

    # 使用自由电子的波函数做为初始猜测的电子波函数，可以加速收敛
    E, ψ = eigs(-∇²./2.0, nev=nlevel, which=:LM, sigma=0)
    ρ = get_density(fn, ψ, Δx)

    for i in 1:max_iter
        H = get_hamiltonian(x, ρ, V_harm)

        E0, ψ0 = eigs(H, nev=nlevel, which=:LM, sigma=0)
        E .= E0
        ψ .= ψ0

        E_tot = sum(E .* fn)  # 求占据态电子能量之和
        ΔE = E_tot - log0["E"][end]
        push!(log0["E"], E_tot)
        push!(log0["ΔE"], ΔE)
        printfmtln("step: {:5d} E: {:10.4f} ΔE {:14.10f}", i, log0["E"][end], log0["ΔE"][end])

        # 判断基能量是否收敛
        if abs(ΔE) < E_threshold
            println("converged!")
            break
        end

        # 更新电子密度
        ρ .= get_density(fn, ψ, Δx)
    end

    p = plot(x, ψ[:, 1:5], label=sprintf1.("%.3f", E[1:5]'), title="ψ")
end

它运行时会出现下面的日志输出（以 \(V_\text{ext} = V_\text{empty}\) 为例）：

step:     1 E:   191.3250 ΔE           -Inf
step:     2 E:   188.6149 ΔE  -2.7101725428
step:     3 E:   189.9835 ΔE   1.3686497726
step:     4 E:   189.2422 ΔE  -0.7413493772
step:     5 E:   189.7313 ΔE   0.4891692181
step:     6 E:   189.4190 ΔE  -0.3123247101
step:     7 E:   189.6381 ΔE   0.2191170430
step:     8 E:   189.4893 ΔE  -0.1488193569
step:     9 E:   189.5950 ΔE   0.1057145189
step:    10 E:   189.5214 ΔE  -0.0735956265
step:    11 E:   189.5738 ΔE   0.0523625987
step:    12 E:   189.5369 ΔE  -0.0368426628
step:    13 E:   189.5631 ΔE   0.0262003363
step:    14 E:   189.5446 ΔE  -0.0185224236
step:    15 E:   189.5578 ΔE   0.0131633325
step:    16 E:   189.5484 ΔE  -0.0093260810
step:    17 E:   189.5551 ΔE   0.0066245797
step:    18 E:   189.5504 ΔE  -0.0046981797
step:    19 E:   189.5537 ΔE   0.0033362576
step:    20 E:   189.5513 ΔE  -0.0023672119
step:    21 E:   189.5530 ΔE   0.0016807098
step:    22 E:   189.5518 ΔE  -0.0011928024
step:    23 E:   189.5527 ΔE   0.0008468043
step:    24 E:   189.5521 ΔE  -0.0006010437
step:    25 E:   189.5525 ΔE   0.0004266762
step:    26 E:   189.5522 ΔE  -0.0003028617
step:    27 E:   189.5524 ΔE   0.0002149933
step:    28 E:   189.5523 ΔE  -0.0001526097
step:    29 E:   189.5524 ΔE   0.0001083320
step:    30 E:   189.5523 ΔE  -0.0000768987
step:    31 E:   189.5523 ΔE   0.0000545872
step:    32 E:   189.5523 ΔE  -0.0000387486
step:    33 E:   189.5523 ΔE   0.0000275059
step:    34 E:   189.5523 ΔE  -0.0000195251
step:    35 E:   189.5523 ΔE   0.0000138599
step:    36 E:   189.5523 ΔE  -0.0000098385
converged!

和前面一样，把波函数和电子密度函数画出来，如下图所示：

下面以 \(V_\text{empty}\) 为例，对比一下原来的波函数与 DFT 方法算出的 KS 波函数的变化：

可以看到， KS 波函数的空间分布与原来无相互作用波函数空间分布差别很大， KS 波函数的波包的顶点都发生了偏移，说明库仑相互作用和交换相互作用影响较大。例如 \(\psi_1\) ，无相互作用体系里波函数分布最大的地方在 \(x=0\) 处，但 KS 波函数里空间分布最大的地方在 \(x=\pm 4.2\) 处左右，表明其它能级更高的电子对它的分布也产生了显著的影响。除此之外，波函数的本征值也变化巨大。实际上这里的对比不太严谨：原来无相互作用体系的波函数是一个电子在不同能级的波函数，而 KS 波函数则被当成是一个含有 N 个电子的体系里每个电子的波函数，这两者概念上的差异不能忽略。

需要注意的是，尽管我们习惯用 KS 轨道表示真实体系里每个电子的轨道，但 KS 轨道实质上仍是单粒子 Schrodinger 方程的解，它能否代替体系真实的波函数仍需要 check ，本人不认为这两者等价。比如在 Ren Xinguo 老师的课件² 里是这样描述的

KS orbitals are auxiliary variables, and have no strict physical meaning (except for HOMO and LUMO).

即除了 HOMO 和 LUMO 之外， KS 波函数仅仅作为计算电子密度函数 \(\rho(\text r)\) 的辅助函数之用。 HOMO 和 LUMO 在一定程度上可以视作体系的真实轨道，此时体系的第一电离能即为 HOMO 的能量（Janak theorem, 1978）：

\[ I = E_0(N-1) - E_0(N) = -\epsilon_N \]

下面来看一下电子密度函数的变化：

很明显，经过自洽迭代后，体系的电子密度分布也发生了变化，对比占据态轨道的变化而言，电子密度的变化还是比较小的。

如果考虑电子的自旋，我们需要修改交换关联泛函，即使用考虑电子自旋的 LSDA 泛函，此时体系的波函数表示也需要随之修改， \(\psi_i(x)\) 变为 \(\psi_i(x, \sigma)\) ，即增加了一个自旋维度 \(\sigma\) 。具体的泛函形式比较复杂，这里作为一个 toy 介绍就不展开了，如果有兴趣可以去看 Ren Xinguo 老师的课件。

总结与拓展

我们实现了一个简单的 DFT 计算程序，它可以使用自定义的外场势能函数，考虑 Hartree 势，并使用 LDA 近似。通过求解 KS 方程，我们得到了 KS 波函数，并与无相互作用体系的波函数作对比，发现波函数的分布发生了显著的变化，同时波函数的能量也发生了不小的变化。在实现的过程中，本人对那句“通过 DFT 将多体系统映射到单粒子系统” 可能有了一些很浅薄的理解。

尽管这是一个很简单的 toy ，但它也是包含了 DFT 计算所需的各种常见操作，比如构造电子密度函数，比如自洽迭代求解 KS 方程，再比如求 Hartree 势函数、使用 LDA 近似等等，这些都可以在常见的 DFT 软件里找到，那么此次 DIY 的过程也能加强对其它成熟 DFT 软件里运行时做了什么有了大概了理解。如果有人想要进一步拓展这个 toy ，我想到了以下几个方向：

考虑上下自旋，使用 LSDA 近似
使用 GGA 泛函（比如 PBE 泛函）
考虑外加电场，这个比较好办，直接在修改外场势函数即可
考虑外加磁场，这个需要修改 Hamiltonian 中的动能项表达式，添加矢势项
考虑相对论效应，使用 Dirac 方程代替 Schrodinger 方程，看是否能算出自旋轨道耦合效应
……

出于精力限制，本人可能没动力继续往下扩展，读者如果有兴趣，可以自行尝试。

tamuhey 的代码 https://github.com/tamuhey/python_1d_dft ↩︎
任老师的课件 http://lqcc.ustc.edu.cn/renxg/plus/list.php?tid=7 ↩︎

使用数值方法求解单电子 Schrodinger 方程

Fri, 06 Aug 2021 14:44:00 +0800

Table of Contents

经常有人觉得会解薛定谔方程会给人一种很厉害的感觉（尤其是对还没学过 QM QC 等课程中学生小朋友而言），确实，现在能写出解析解的 Schrodinger 方程屈指可数；而且仅仅增加粒子数量不考虑各种修正就足以使求解的难度上升一大截。不过在这里我们不考虑多个粒子的情况，也不考虑什么相对论效应 blabla ，我们只考虑一个电子在一个任意势场下的定态 Schrodinger 方程，然后来用数值方法求解这个方程，得到电子的波函数并可视化，顺便验证一下教材上各种电子轨道的分布图，体验一把亲手解 Schrodinger 方程的感觉。

这里本文是在实空间的笛卡尔坐标系进行求解。

单粒子定态 Schrodinger 方程

考虑一个电子在势场 \(V\) 中，它的定态 Schrodinger 方程是

\begin{equation} \hat{H} \Psi(x, y, z) = E\Psi(x, y, z) \end{equation}

如果这个势场是 \(V = 0\) ，并且限定这个电子在一个边长为 \(a\) 的箱子内，此时 Schrodinger 方程就变成了

\begin{equation} -\frac{\hbar^2}{2m} \left( \frac{\partial^2}{\partial x^2} + \frac{\partial^2}{\partial y^2} + \frac{\partial^2}{\partial z^2} \right) \Psi(x, y, z) = E\Psi(x, y, z) \end{equation}

这个方程可以写出解析解¹ （参加过考试的同学应该能默写这个公式了）：

\[E = (n_x^2 + n_y^2 + n_z^2) \frac{h^2}{8ma^2}\]

\[ \begin{aligned} \Psi(x, y, z) &={} X(x)Y(y)Z(z) \newline &={} \sqrt{\frac{8}{a^3}}\sin(\frac{n_x \pi x}{a})\sin(\frac{n_y \pi y}{a})\sin(\frac{n_z \pi z}{a}) \end{aligned} \]

这是三维情况下的解，如果体系只有一维，它的能级表达式是

\[ E = \frac{n^2 h^2}{8ma^2} \newline \Psi(x) = \sqrt{\frac{2}{a}} \sin(\frac{n \pi x}{a}) \]

这是它们的解析解，也是我们后面验证结果正确性的参考。以上结果的推导请参考任意一本《量子力学》或《量子化学》或者《结构化学》。

有限差分法

所谓有限差分法，就是有限差分来近似导数，从而寻求微分方程近似解的方法。针对导数的有限差分操作可以参考 Wikipedia ²，简单来说就是用各种近似方法来逼近导数的值。

假设存在一个离散的函数 \(f(x), x = x_1, x_2, … , x_n\) ，并且 \(x_{i+1} - x_{i} = \Delta x\) 为一定值，根据有限差分的推导，可以得到下面的结论：

一阶导数的离散化

这里使用一种最为常见的离散化方法来近似一阶导数：

\begin{equation} f'(x_i) \approx \frac{f(x_i+\Delta x) - f(x_i - \Delta x)}{2\Delta x} = \frac{f(x_{i+1}) - f(x_{i-1})}{2\Delta x} \end{equation}

再假设 \(f(x)\) 可以写成一个列向量 \(\ket{f} = \begin{bmatrix} f(x_1), f(x_2), \cdots, f(x_n) \end{bmatrix}^T\) ，那么一阶导数算符 \(\dfrac{d}{dx}\) 可以写成

\[\frac{d}{dx} \begin{bmatrix} f(x_1)\newline f(x_2) \newline \vdots \newline f(x_n) \end{bmatrix} = \frac{1}{2\Delta x} \begin{bmatrix} 0 & 1 & & & \newline -1 & 0 & 1 & & \newline & -1 & 0 & \ddots & \newline & & \ddots & \ddots & 1 \newline & & & -1 & 0 \end{bmatrix} \cdot \begin{bmatrix} f(x_1)\newline f(x_2) \newline \vdots \newline f(x_n) \end{bmatrix} \]

这是在没有处理边界条件的情况下的一阶导数算符，如果考虑周期性边界条件，上式矩阵的左下角和右上角分别为 1 和 -1 。此外这种方法近似得到的一阶导的精度是 \(O((\Delta x)^2)\) ，更高阶的近似及其它非对称的方法请参考本节之前提到的 Wikipedia 。

二阶导数的离散化

比较常见的二阶导数离散化方法如下：

\begin{equation}\begin{aligned} f'(x_i+\frac{1}{2} \Delta x) &\approx{} \frac{f(x_i + \Delta x) - f(x_i)}{\Delta x} = \frac{f(x_{i+1}) - f(x_i)}{\Delta x} \newline f'(x_i-\frac{1}{2} \Delta x) &\approx{} \frac{f(x_i) - f(x_i - \Delta x)}{\Delta x} = \frac{f(x_i) - f(x_{i-1})}{\Delta x} \newline f''(x_i) &\approx{} \frac{ f'(x_i+\frac{1}{2} \Delta x) - f'(x_i-\frac{1}{2} \Delta x) }{\Delta x} \newline &={} \frac{ f(x_{i+1}) + f(x_{i-1}) - 2f(x_i) }{(\Delta x)^2} \end{aligned}\end{equation}

同样，它也可以用矩阵的形式表达出来：

\[ \frac{d^2}{dx^2} \begin{bmatrix} f(x_1)\newline f(x_2) \newline \vdots \newline f(x_n) \end{bmatrix} = \frac{1}{(\Delta x)^2} \begin{bmatrix} -2 & 1 & & & \newline 1 & -2 & 1 & & \newline & 1 & -2 & \ddots & \newline & & \ddots & \ddots & 1 \newline & & & 1 & -2 \end{bmatrix} \cdot \begin{bmatrix} f(x_1)\newline f(x_2) \newline \vdots \newline f(x_n) \end{bmatrix} \]

如果需要考虑周期性边界条件，矩阵的左下角和右上角都应为 1 。这种方法近似的精度是 \(O((\Delta x)^2)\) 。

一维系统 Hamiltonian 的构造及求解

一维势箱模型系统的求解

Hamiltonian 的整体表达式为

\[ H = T + V \]

如果系统只有一维，那么 Hamiltonian 很好构造，直接在 \(T\) 的基础上加上势能即可

\[H = \frac{1}{(\Delta x)^2} \begin{bmatrix} -2 & 1 & & & \newline 1 & -2 & 1 & & \newline & 1 & -2 & \ddots & \newline & & \ddots & \ddots & 1 \newline & & & 1 & -2 \end{bmatrix} + \begin{bmatrix} V_1 & & & \newline & V_2 & & \newline & & \ddots & \newline & & & V_n \end{bmatrix} \]

然后我们的问题就变成了

\[ H \ket{\psi} = E\ket{\psi} \]

这是一个典型的本征值问题，只要对 \(H\) 进行对角化就可以得到我们想到的能量 \(E\) 和波函数 \(\ket{\psi}\) 。下面是它的程序实现（本文使用 Julia 作为有限差分法的实现语言）

#!/usr/bin/env julia

using LinearAlgebra;
using SparseArrays;
using Arpack;
using Plots;

################################################################################
#
#                           Constants Part
#
################################################################################

const N = 5000;                 # sample points
const len = 1.0;                # box length

const k = 3.8099821161548593;   # hbar^2 / (2*m_e) = (Å^2) / eV
const m = 1.0;                  # relative mass of electron

const nev = 4;                  # number of eigen values to be covered

x = LinRange(0.0, len, N);
const dx = len / N;

################################################################################
#
#                           Hamiltonian Part
#
################################################################################

T_ = sparse(-2.0I, N, N);
T_[diagind(T_,  1)] .= 1.0;
T_[diagind(T_, -1)] .= 1.0;
T_ *= -k / (m * dx * dx);

T = deepcopy(T_);
H = T;

println("Hamiltonian constructed, start solving ...");
@time λ, ϕ = eigs(H, nev=nev, which=:LM, sigma=0.0);
@show λ

################################################################################
#
#                           Hamiltonian Part
#
################################################################################

for i in 1:nev
    ϕ[:,i] ./= norm(ϕ[:, i]) * sqrt(dx)   # Normalization
    @assert sum(ϕ[:, i].^2) * dx ≈ 1.0    # verify the norm: ∫ |ϕ|² dx == 1
end

@show maximum(ϕ[:, 1])

p = plot(x, ϕ, layout=(2, 2), size=(800, 600));
savefig(p, "./1D-particle-in-a-box-eigvec.svg");

Hamiltonian ready, start solving ...
  1.991257 seconds (7.25 M allocations: 439.625 MiB, 8.56% gc time, 99.53% compilation time)
λ = [37.58797833051402, 150.3518984879221, 338.29171597315013, 601.4073566198176]
maximum(ϕ[:, 1]) = 1.4140720924720651

下面我们来验证一下程序的结果：

程序中有 \(k = \hbar^2 / 2m_e = 3.80998 (\mathrm{Å^2/eV})\) ，它把一些物理常数打包处理并化为原子单位制，因此在和解析解对比时也要以此为准，此外程序中定义 \(a=1Å\) ，没有显式处理边界条件。势箱模型中解析解为

\[ E = \frac{n^2 h^2}{8ma^2} = \frac{\hbar^2}{2m} \cdot \frac{4\pi^2 n^2}{4a^2} = \frac{kn^2\pi^2}{a^2} \]

代入 \(k\) 和 \(a\) ，得到 \(E_1 = 37.6029953761\) ，与数值解 \(\lambda_1=37.58797833051402\) 对比相当接近，继续验证 \(\lambda_2\) 、 \(\lambda_3\) 等可以发现它们也符合 \(n^2\) 的增长曲线（读者可自行验证）。

再来验证一下波函数：

它显然符合正弦曲线的特征，并且在边界处为 0 ，最大值为 1.414072 与归一化因子 \(\sqrt{2} = 1.414213\) 相差也在允许范围内，因此现在可以放心地说，如果 \(T\) 没有特殊边界条件处理，它的边界条件就是使边界处的波函数为 0 ，这在后面的计算中可以得到进一步验证。

带有 Chulkov 势的一维势箱系统求解

上面的系统中电子不受束缚， Hamiltonian 里没有势能这一项，这也就没有验证势能项加在对角线上的合理性，下面我们使用一种于二十年前被提出的势能函数来验证这一点。

Chulkov ³ 等于 1997 年提出一种势能用于模拟出金属表面的镜像态。它以金属表面为 0 点， 0 以下使用正弦函数模拟金属的体相内的势能， 0 及以上使用正弦及指数函数等模拟金属表面以外的镜像势，它有如下形式：

\[ V_m(z) = \begin{cases} -A_{10} + A_1 \cos \left( \frac{2\pi}{d_m} z \right) & z \le 0 \newline -A_{20} + A_2 \cos(\beta z) & 0 < z \le z_1 \newline -A_3 \exp\left[-\alpha(z-z_1)\right] & z_1 < z \le z_\mathrm{im} \newline \dfrac{\exp\left[ -\lambda (z-z_\mathrm{im}) \right]-1}{4(z-z_\mathrm{im})} & z > z_\mathrm{im} \end{cases} \]

体现在图像上是这个样子的：

这里选择用于 Ag(111) 表面的各参数，代码如下：

#!/usr/bin/env julia

# Reference: Image potential states on metal surfaces: binding energies and wave functions
#             https://www.sciencedirect.com/science/article/pii/S0039602899006688

using LinearAlgebra;
using SparseArrays;
using Arpack;
using Plots;


const N = 15000;
const len = 150.0;

const k = 3.8099821161548593    # hbar^2 / (2*m_e) /(Å^2) / eV
const k_c = 14.39964547842567   # (e*e / (4 * np.pi * epsilon_0))  # measured in eV / Å
const m = 1.0                   # mass of electron

const dx = len / N;

const nev = 8;

################################################################################
#
#                                Potential Part
#
################################################################################

#=
#
# V1(z) = -A10 + A1*cos(2pi*z/dm)    z <= 0
# V2(z) = -A20 + A2*cos(beta*z)      0 < z <= z1
# V3(z) = -A3 * exp(-alpha*(z-z1))   z1 < z <= zim
# V4(z) = (exp(-lambda*(z-zim))-1.0) / (4.0*(z-zim))  z > zim
#
=#

const a0 = 0.529;# A, bohr raidus
const as = 4.43; # a.u.
const A10 = 9.64;# eV
const A1 = 4.30; # eV
const A2 = 3.8442; # eV
const beta0 = 2.5649; # 1/a.u.
const zim0 = 2.35; # a.u.

const dm = as * a0; # A
const A20 = A10 + A2 - A1; # eV
const beta = beta0 / a0; # A^-1
const zim = zim0 * a0; # A
# const A3 = A2 / sqrt(2); # eV
const z1 = 5*pi/(4*beta); # A
const A3 = A20 - A2*cos(beta*z1); # eV
const alpha = - A2*beta*sin(beta * z1) / A3; # A^-1
const lambda = 4*A3*exp(-alpha*(zim - z1)) / k_c; # A^-1

@show A10 A1 dm A20 A2 beta A3 alpha z1 lambda zim

z = LinRange(-len/2, len/2, N);
V = similar(z);

@. V[z<=0]      = -A10 + A1 * cos(2pi * z[z<=0] / dm)
@. V[0<z<=z1]   = -A20 + A2 * cos(beta * z[0<z<=z1])
@. V[z1<z<=zim] = - A3 * exp(-alpha * (z[z1<z<=zim] - z1))
@. V[z>zim]     = (exp(-lambda * (z[z>zim] - zim)) - 1.0) / (4.0 * (z[z>zim] - zim)) * k_c

################################################################################
#
#                           Hamiltonian Part
#
################################################################################

Ident = sparse(1.0I, N, N);
T_ = sparse(-2.0I, N, N);
T_[diagind(T_,  1)] .= 1.0;
T_[diagind(T_, -1)] .= 1.0;
T_ *= -k / (m * dx * dx);

T = deepcopy(T_);

H = T;
H[diagind(H)] .+= V;
Vmin = -1.0;

λ, ϕ = eigs(H, nev=nev, which=:LM, sigma=min(0, Vmin));
@show λ

for i in 1:nev
    ϕ[:,i] ./= norm(ϕ[:,i]) * sqrt(dx)      # normalization
    @assert  sum(ϕ[:,i].^2) * dx ≈ 1.0      # test norm
end

p = plot(z, ϕ.^2, layout=(4,2), size=(800, 600));
savefig(p, "./1D-chulkov-eigvec.svg");

下面是计算结果与文献值对比

Table 1: 有限差分法计算 Chulkov 势结果与文献值对比

λ	计算结果(eV)	文献值(eV)	实验值(eV)
1	-0.788	−0.77	-0.77
2	-0.674	-	-
3	-0.533	-	-
4	-0.330	-	-
5	-0.208	-0.22	-0.23
6	-0.103	-0.095	-0.10
7	-0.061	-0.053	-0.052
8	-0.031	-	-

上面表中有一些态主要分布在体相内，文献和实验中没有测到。为更明显地对比镜像态与 bulk 态的区别，这里使用 \(|\phi|^2\) 作图：

显然， \(\phi_2\) 、 \(\phi_3\) 和 \(\phi_4\) 大部分都处于体相内，从包络线的形状看，它们类似于刚刚讨论过的势箱内的态，但这些态不属于镜像态，所以在与实验对比时应排除在外。而 \(\phi_1\) 、 \(\phi_5\) 、 \(\phi_6\) 和 \(\phi_7\) 在真空中的部分存在波包，且波包的数量刚好对应主量子数 \(n\) ，如 \(\phi_5\) 在 \(x\ge 0\) 的部分有两个波包，它就是 \(n=2\) 对应的本征态。

二维及更高维系统的 Hamiltonian 构造与求解

一维情况下我们可以直接使用二阶导而无需其它处理即可构造出动能算符，但在更高维度下要如何构造动能算符，以及 Hamiltonian 呢？

高维 Laplacian 的离散化

根据 Wikipedia ⁴ 上关于离散 Laplacian （拉普拉斯算符）的描述，多维离散 Laplacian 是一维离散 Laplacian 的 Kronecker Sum （克罗内克和）。

例如对于一个二维系统：

\[ L = \bold{D}_\bold{xx} \oplus \bold{D}_\bold{yy} = \bold{D}_\bold{xx} \otimes \bold{I} + \bold{I} \otimes \bold{D}_\bold{yy} \]

其中 \(\bold{D}_\bold{xx}\) 、 \(\bold{D}_\bold{yy}\) 表示在 \(x\) 、 \(y\) 方向上的 Laplacian 矩阵， \(\bold{I}\) 是单位矩阵。

注意，上式中 “\(\oplus\)” 表示 Kronecker Sum 操作而不表示矩阵 Direct Sum （直和）操作，尽管它们所用的符号是一样的；而 “\(\otimes\)” 则可以理解为 Kronecker Product 或者 Direct Product （直积）操作，因为在此处可以认为两种操作等价。

相应地，对于一个三维系统，它的 Laplacian 应该是

\[ L = \bold{D}_\bold{xx} \otimes \bold{I} \otimes \bold{I} + \bold{I} \otimes \bold{D}_\bold{yy} \otimes \bold{I} + \bold{I} \otimes \bold{I} \otimes \bold{D}_\bold{zz} \]

下面通过计算二维势箱内的电子能级来验证上面式子的正确性。

假设二维势箱是边长 \(a = 1 \rm{Å}\) 的正方形，其中的电子满足 Schrodinger 方程：

\[\begin{aligned} -\frac{\hbar^2}{2m_e}(\frac{\partial^2}{\partial x^2} + \frac{\partial^2}{\partial y^2}) \psi = E\psi \end{aligned}\]

它的 Hamiltonian 只包含 Laplacian ，解析解为

\[\begin{aligned} E &={} (n_x^2 + n_y^2)\frac{h^2}{8ma^2} \newline \psi(x, y) &={} \frac{2}{a}\sin(\frac{n_x \pi x}{a}) \sin(\frac{n_y \pi y}{a}) \end{aligned}\]

程序实现如下：

#!/usr/bin/env julia

using LinearAlgebra;
using SparseArrays;
using Arpack;
using Plots;

################################################################################
#
#                           Constants Part
#
################################################################################

const N = 200;                 # sample points
const len = 1.0;                # box length

const k = 3.8099821161548593;   # hbar^2 / (2*m_e) = (Å^2) / eV
const m = 1.0;                  # relative mass of electron

const nev = 8;                  # number of eigen values to be covered

x = LinRange(0.0, len, N);
y = LinRange(0.0, len, N);
const dx = len / N;
const dy = len / N;

################################################################################
#
#                           Hamiltonian Part
#
################################################################################

Tx = sparse(-2.0I, N, N);
Tx[diagind(Tx,  1)] .= 1.0;
Tx[diagind(Tx, -1)] .= 1.0;
Tx *= -k / (m * dx * dx);
Ix = sparse(1.0I, N, N);

Ty = sparse(-2.0I, N, N);
Ty[diagind(Ty,  1)] .= 1.0;
Ty[diagind(Ty, -1)] .= 1.0;
Ty *= -k / (m * dx * dx);
Iy = sparse(1.0I, N, N);

T_ = kron(Tx, Iy) + kron(Ix, Ty);

T = deepcopy(T_);
H = T;

println("Hamiltonian constructed, start solving ...");
@time λ, ϕ = eigs(H, nev=nev, which=:LM, sigma=0.0);
@show λ

################################################################################
#
#                           Visualization Part
#
################################################################################

for i in 1:nev
    ϕ[:,i] ./= norm(ϕ[:, i]) * dx   # Normalization
    @assert sum(ϕ[:, i].^2) * dx^2 ≈ 1.0    # verify the norm: ∫ |ϕ|² dx == 1
end

@show maximum(ϕ[:, 1])

ψ = reshape(ϕ, N, N, nev);

p1 = surface(x, y, ψ[:, :, 1], title="ψ_1");
p2 = surface(x, y, ψ[:, :, 2], title="ψ_2");
p3 = surface(x, y, ψ[:, :, 3], title="ψ_3");
p4 = surface(x, y, ψ[:, :, 4], title="ψ_4");
p = plot(p1, p2, p3, p4, layout=(2, 2), size=(800, 500));
savefig(p, "./2D-particle-in-a-box-eigvec.svg");

解得本征值与解析解对比如下：

\(\lambda\)	\(n_x^2 + n_y^2\)	\(E_{\rm numerical}\) (eV)	\(E_{\rm analytical}\) (eV)
1	1 + 1 = 2	74.458	75.206
2	4 + 1 = 5	186.136	187.961
3	1 + 4 = 5	186.136	187.961
4	4 + 4 = 8	297.814	300.737
5	9 + 1 = 10	372.236	375.922
6	1 + 9 = 10	372.236	375.922
7	9 + 4 = 13	483.914	488.698
8	4 + 9 = 13	483.914	488.698

解得的本征值相差还是不小的，但总体趋势是一致的。解得波函数如下（限于篇幅原因只列举前四个）:

根据波函数形状判断，它们与量子数的对应关系如下：

\(\psi\)	\(n_x\)	\(n_y\)	\(E\) (eV)
1	1	1	74.458
2	2	1	186.136
3	1	2	186.136
4	2	2	297.814

在归一化波函数后，求得振幅为 1.990 ，与 \(\dfrac{2}{a} = 2\) 相差无几。

由此可见，使用 Kronecker Sum 构造的 Laplacian 解出的结果是正确的。

高维 Hamiltonian 的构造与求解

已经有了高维的 Laplacian ，我们需要把势能项和 Laplacian 组合起来得到 Hamiltonian 。显然，我们需要把势能加到对角项上，但要注意一个问题，就是 Laplacian 的对角项与格点的对应关系：

\[ L = \bold{D}_\bold{xx} \otimes \bold{I} \otimes \bold{I} + \bold{I} \otimes \bold{D}_\bold{yy} \otimes \bold{I} + \bold{I} \otimes \bold{I} \otimes \bold{D}_\bold{zz} \]

我们不妨令 \(\bold{D}_\bold{xx}\) 为 \(\bold{X}\) ， \(\bold{D}_\bold{yy}\) 为 \(\bold{Y}\) ， \(\bold{D}_\bold{zz}\) 为 \(\bold{Z}\)，根据 Kronecker Product 的运算过程（详见 Wiki），最后得到的矩阵对角线应该是

\[\begin{bmatrix} \bold{X}_{11} \bold{Y}_{11} \bold{Z}_{11} & & & \newline & \bold{X}_{11} \bold{Y}_{11} \bold{Z}_{22} & & \newline & & \bold{X}_{11} \bold{Y}_{11} \bold{Z}_{33} & \newline & & & & \ddots \end{bmatrix}\]

上式中 \(\bold{Z}\) 的对角线，即最后一个维度的下标增长得最快；对应地，在加和势能项时，也应该是最后一个维度增长最快，这恰好是访问一个行主序的多维数组元素时的访问顺序。也就是说我们只需要按照行主序的顺序把多维的势能数组展开为一维数组，然后加和到 Laplacian 上即可得到 Hamiltonain ：

\[H = T + \begin{bmatrix} V_{111} & & & \newline & V_{112} & & \newline & & V_{113} & \newline & & & \ddots \end{bmatrix}\]

此处我们选取静态氢原子的电子为求解对象，它的 Shrodinger 方程是这个形式

\[ -\frac{\hbar^2}{2m_e} \nabla^2 \psi - \frac{e^2}{4\pi \epsilon_0} \frac{1}{r} \psi = E\psi \]

下面是程序实现，注意 Julia 的数组是列主序，因此在组合 Hamiltonian 时需要转换；除此之外受计算机性能和辣鸡 ARPACK 的限制，这里每个维度只取 50 个点，每个维度各取 30Å 的长度。

#!/usr/bin/env julia

using LinearAlgebra;
using SparseArrays;
using Arpack;
using WriteVTK;

# Auxiliary function
function mgrid(xs...)
    it = Iterators.product(xs...);
    ret = [];
    for i in 1:length(xs)
        push!(ret, getindex.(it, i));
    end
    return ret;
end


################################################################################
#
#                                Constants Part
#
################################################################################

const k   = 3.8099821161548593  # hbar^2 / (2*m_e) /(Å^2) / eV
const k_c = 14.39964547842567   # (e*e / (4 * np.pi * epsilon_0))  # measured in eV / Å
const m   = 1.0                 # mass of electron

const xlen = 30.0;
const ylen = xlen;
const zlen = xlen;

const N = 50;
const dx = xlen / N;

# generate the grid
const x = range(-xlen/2, xlen/2, length=N);
const y = range(-ylen/2, ylen/2, length=N);
const z = range(-zlen/2, zlen/2, length=N);

const nev = 10;

################################################################################
#
#                                Potential Part
#
################################################################################

gx, gy, gz = mgrid(x, y, z);
function potential(gx, gy, gz) ::AbstractArray
    r = sqrt.(gx.^2 + gy.^2 + gz.^2);
    r[r .< 0.0001] .= 0.0001;
    return -k_c ./ r;
end

V = potential(gx, gy, gz);
Vmin = minimum(V)


################################################################################
#
#                                Hamiltonian Part
#
################################################################################

# Kinetic part
Identity = sparse(1.0I, N, N);

T_ = sparse(-2.0I, N, N);
T_[diagind(T_,  1)] .= 1.0;
T_[diagind(T_, -1)] .= 1.0;

T_ .*= -k / (m * dx*dx)

T = kron(T_, kron(Identity, Identity)) +
    kron(Identity, kron(T_, Identity)) +
    kron(Identity, kron(Identity, T_));

# Hamiltonian
H = deepcopy(T);
H[diagind(H)] .+= permutedims(V, [3, 2, 1])[:];


# Solve the equation Hψ = Eψ
@time λ, ϕ = eigs(H, nev=nev, which=:LM, sigma=min(0, Vmin));
@show λ


################################################################################
#
#                                Visualization Part
#
################################################################################

vtk_grid("HydrogenAtom", x, y, z) do vtk
    for i in 1:nev
        ϕ[:, i] ./= norm(ϕ[:,i]) * dx * sqrt(dx);
        @assert sum(ϕ[:,i].^2) * dx^3 ≈ 1.0
        vtk["phi_$i"] = reshape(ϕ[:, i], N, N, N);
    end
end

结果与解析值对比

\(\lambda\)	\(n\)	\(E_{\rm numernical}\) (eV)	\(E_{\rm analytical}\) (eV)
1	1	-10.713	-13.6
2	2	-3.417	-3.4
3	2	-3.417	-3.4
4	2	-3.417	-3.4
5	2	-3.031	-3.4
6	3	-1.515	-1.51
7	3	-1.515	-1.51
8	3	-1.515	-1.51
9	3	-1.474	-1.51
10	3	-1.474	-1.51

本征值与解析值对应得并不好，尤其是基态的能量，与解析解相差了近 3eV ，这是因为 \(1s\) 态主要局域在原子核附近，而求数值解时每个维度只取了 50 个点，

本征态如下（这里只取前五个态）：

它们分别对应氢原子的 \(1s\) 态、 \(2p_y\) 态、 \(2p_z\) 态、 \(2p_x\) 态和 \(2s\) 态，抛去过于粗糙的格点和不太准的本征值不谈，它们的形状与实验上符合得还是很好的。

以上结果可以证明 Hamiltonian 的构造是合理的。

有限元法

注：本人刚刚接触 FEM ，这里只是简单谈谈有限元法，以能通过改示例跑通自己的问题为标准，因此对它的各项论述十分粗浅且可能存在错误，欢迎专业人士指正。

上面我们讨论了使用有限差分法求解 Schrodinger 方程的过程，除了有限差分法，还有一种在 CAE 领域应用非常广泛的方法——有限元法，也能用来求解 Schrodinger 方程。简单且不负责任地说，有限元与有限差分最大的区别在于有限元的元素是大小、形状均可变，并且它可以随意调整求解空间的形状以及网格的形状、局部疏密等等，这使得它可以对各种奇怪的体系进行求解。

定态 Schrodinger 方程的变分弱解形式

之前本文给出过定态 Schrodinger 方程

\[ -\frac{\hbar^2}{2m}\nabla^2 \psi + V\psi = E\psi \]

它其实是偏微分方程的 Strong Form （强解形式），而在 FEM 领域中常常使用 Weak Form （弱解形式）来描述一个偏微分方程。经过查阅资料，我找到的 Shrodinger 方程的弱解形式如下：

\[\begin{aligned} \frac{\hbar^2}{2m} \int_{\Omega} \left( \frac{\partial u}{\partial x} \frac{\partial v}{\partial x} + \frac{\partial u}{\partial y} \frac{\partial v}{\partial y} + \frac{\partial u}{\partial z} \frac{\partial v}{\partial z} \right) + \int_{\Omega} Vuv = \int_{\Omega} Euv \end{aligned}\]

上式中 \(u\) 是我们要求解的波函数， \(v\) 是测试函数， \(\Omega\) 是有限元空间。看起来这个式子和 Schrodinger 方程的强解形式差不多，只是动能项前面没有负号了。具体推导过程详见 Weak formulation of Poisson’s equation ⁵ 或 Weak formulation of quantum harmonic oscillator ⁶。

程序实现及结果验证

有了弱解形式的 Schrodinger Equation 后就可以开始使用有限元法求解了，这里使用 FreeFEM++ ⁷ 作为实现语言。

使用 FreeFEM++ 求解本征值问题时主要有以下步骤：

定义网格；
定义有限元空间；
定义需要解决的问题，即用代码表达弱解形式的偏微分方程；
调用求解器求解；
输出结果以及可视化结果等。

这里以求解氢原子为例，求解空间为 30Åx30Åx30Å 的正方体，边缘格点数为 40x40x40 ，使用 P1 有限元空间。下面是代码

load "msh3"
load "iovtk"

int nn = 40;

real ka = 3.8099821161548593; // hbar^2 / 2m_e
real kc = 14.39964547842567; // e^2 / (4pi epsilon_0)

mesh3 Th = cube(nn, nn, nn, [30*x-15, 30*y-15, 30*z-15]);
plot(Th, wait=1);

fespace Vh(Th, P1);

cout << "Th :  nv = " << Th.nv << " nt = " << Th.nt << endl;

real sigma = -13;

macro Grad(u) [dx(u), dy(u), dz(u)] // EOM
varf a(u1, u2) = int3d(Th) (
    Grad(u1)' * Grad(u2) * ka
    - 1.0 / sqrt(x^2 + y^2 + z^2)  * u1 * u2 * kc
    - sigma * u1 * u2
    )
    //+ on(1, 2, 3, 4, 5, 6, u1=0.0)   // boundary condition
    ;

varf b([u1], [u2]) = int3d(Th) ( u1 * u2 ) ;

matrix A = a(Vh, Vh);
matrix B = b(Vh, Vh);

int nev = 20;
real[int] ev(nev);
Vh[int] eV(nev);

int k = EigenValue(A, B, sym=true, sigma=sigma, value=ev, vector=eV, tol=1e-10);

k = min(k, nev);

for (int i=0; i<k; ++i) {
    cout << " ---- " << i << " " << ev[i] << " == " << endl;
    plot(eV[i], cmm="#" + i + " EigenValue=" + ev[i], wait=true);
    savevtk("Eigen_" + i + ".vtk", Th, eV[i], dataname="EigenValue=" + ev[i]);
}

求得本征值如下：

\(\lambda\)	\(E_{\rm numerical}\) (eV)	\(E_{\rm analytical}\) (eV)
1	-10.390	-13.6
2	-3.163	-3.4
3	-3.163	-3.4
4	-2.980	-3.4
5	-2.776	-3.4
6	-1.475	-1.5
8	-1.475	-1.5
7	-1.444	-1.5
9	-1.444	-1.5
10	-1.423	-1.5

可见在这个格点密度下它的精度还是不太高，有些态甚至还比不上有限差分法的精度。

它们的本征态如下：

和有限差分法相比，它的本征态似乎更粗糙一些，实际上这是由于取的网格不够密，以及势能项 \(1/r\) 在 0 处存在奇点难以近似导致的。

尽管有这样的缺陷，但它胜在是一个成熟的开源软件，比之前随便写的 toy 要正式许多，而且它还能使用其它设计软件来建模定义求解的空间，甚至读取其它软件生成的网格进行后续的计算，最重要的一点，它可以集成并行的本征值求解器 SLEPc ⁸ 。经过测试，求解一个 150x150x75 的网格时，在 32 核的服务器上可以用 18 分钟跑完，效率还是令人满意的。

总结及吐槽

总之，本文使用了两种不同的方法在实空间直接求解单电子的 Schrodinger 方程，总体的结果还算满意。有限差分法的算法学习自 GithHub 的一个项目 qmsolve ⁹，作者甚至还把我拉到了这个项目的 Discord 讨论群（现在已经开放）继续讨论。

吐槽

有限差分法的 Hamiltonian 矩阵大小随维度的升高而急剧升高，如果一个问题能在较低的维度解决，不要使用更高的维度，通常情况后者解不动：一维问题的 Hamiltonian 大小是 \(O(N^2)\) ，而三维问题的 Hamiltonian 大小是 \(O(N^6)\) ~~，如果后面有空的话我会考虑写一下柱坐标系内 Schrodinger 方程的求解~~ 。
在使用有限差分法时格点越密，求解所需的时间越多，且耗时呈指数级增长。为此我花了将近一周多的时间在寻找 Julia 能用的并行本征值求解器上，最后发现没有能满足要求的，有几个 C++ / Python 能用的并行求解器，如 SLEPc 和 Trilinos ，但我没去尝试；
Arpack 在处理 60x60x60 的格点时就已经有点力不从心了，超算上显示它只能通过调用 BLAS 来实现部分的并行操作，且最多只有 6 个线程在跑，而且 Arpack 也确实很久没有更新了；
scipy.sparse.eigsh 的效率还不如 Julia 里的 Arpack.eigs ，前者算 50x50x50 的体系就算不动了，而且似乎在超算上用并行也没什么加速效果，尽管所有核都是满载；
FreeFEM++ 的语言乍一看挺像 C++ ，但其实区别还是相当大的，令人惊喜的是它的文档还有一个中文翻译版；
在服务器上编译 FreeFEM++ 也花了我不少时间，这个东西的 Makefile 写得让人头疼： configure 文件直接就是一个 Python 脚本，而且层层套娃，想改什么参数都不好找，那两天被弄得脑壳疼；
FreeFEM++ 支持并行操作，用更密的 Mesh 可以重复出文献上的结果；更重要的是它可以更灵活地指定边界条件；
在可视化 FreeFEM++ 的输出，即 vtk 文件时也遇到了不少麻烦，因为之前从没接触过 vtk 文件，只是听说 ParaView¹⁰ 效果最好，于是从头开始学 ParaView 。不得不说，入门时还是看视频学最快，找谷歌翻论坛很可能不知所云；
实验组最后还要求用求得的波函数计算一下位置算符的期望值，于是我又不得不去翻 ParaView 的手册找怎么操作数据。这个软件和 Python 以及 VTK 深度集成，里面自带一个 Python 解释器，但没有提供内置对象的文档，导致你面对一个 Script 框时连输入是啥都不知道，此外它的一些数据结构在原版 VTK 内还没有，那就只能靠 dir(obj) 来看它的方法列表了，通过不断地翻论坛（2018 年以前的论坛还是在邮件列表上），还是在一个人的回答中找到了相关的信息，算是顺利解决了问题，不得不说这个过程还是挺恶心人的。

这些东西可能读起来几分钟就读完了，但从接到相关的任务，到给出令实验组满意的结果，再到写出这篇博文，整整用掉了一个多月的时间，这期间试了尝试过很多次，不管是有限差分还是有限元，写过很多测试的代码但结果不正确，身边又没有可以请教人时，内心还是有一点绝望的（尤其在 6 月下半旬还夹着报账那个事），中途想过放弃，想着不如直接找个力学系的同学抛给他用 COMSOL 解出来，但最后还是通过翻论坛，厚着脸皮问 developer 等手段把想要的结果算出来了，此时觉得前面的努力还是没有白费，就是对当初对实验组的老师打包票说几天就能算出来，但实际花了近一个月这一点还是有点惭愧的。

镜像态的那些坑

Thu, 06 May 2021 00:18:00 +0800

Table of Contents

本文是帮实验组计算表面态与镜像态相关性质时所遇到一些坑的总结。

限于 DFT 理论上的缺陷（使用指数函数逼近库仑势，从而加速收敛）， DFT 并不能算准 IPS 的能级（误差在 \(\pm 0.3eV\)左右），但有的实验又需要从 DFT 计算获得一些关于 IPS 的信息，于是即使 DFT 不能算准，也无大碍。在这个过程中本人似乎不止一次掉入坑中，于是把这个过程记录下来，即便对后人没什么帮助，也算是对自己学习印迹的一丝收藏吧。

表面态与镜像态

表面态(Surface States, SS)

顾名思义，表面态就是在物体表面附近存在的电子态¹。表面意味着边界的存在，边界外是真空，边界内是原子。正因为存在从体相到真空的剧烈变化，表面的原子存在不饱和键，即悬挂键。这些悬挂键由那些在体相内本应成键的电子贡献，受这些电子影响，物体的表面会出现一些新的、相对弥散的电子态，这些电子态被称为表面态。

镜像态(Image Potential States, IPS)

将一个电荷放在无限大的导体表面（这里假设表面是平面），导体内部会发生极化，导致内部电荷重新分布，从而产生一个静电势。这个静电势等效于导体内一个带相反电性的镜像电荷产生的静电势，因而被称为镜像势。电子因镜像势会在导体表面外形成一些相对弥散的态，这些态就是镜像态。

Figure 1: 镜像电荷示意图， 0+ 侧是真空， 0- 侧是相对介电常数为 epsilon_r 的导体内部

镜像势的势能曲线是反比例曲线：

\[ V(z) = - \frac{\beta e^2}{4\pi \epsilon_{0} \cdot 4z} \]

上式中 \(\beta = \displaystyle\frac{\epsilon_r-1}{\epsilon_r+1}\)

所以电子满足方程：

\[ \begin{aligned} \frac{\hbar^2}{2m_e} \nabla^2 \Psi + V(z)\Psi &={} E\Psi \newline \frac{\hbar^2}{2m_e} \nabla^2 \Psi - \frac{\beta e^2}{4\pi \epsilon_{0} \cdot 4z} \Psi &={} E\Psi \end{aligned} \]

这个方程看起来很眼熟，它十分类似于氢原子 Schrodinger 方程。由于这个电子只在 \(z\) 方向上受镜像电荷作用，因而在 \(xy\) 方向上是自由的，所以它能量可以通过求解一维氢原子 Schrodinger 方程得到：

\[ E_n = -\frac{0.85}{n^2}\frac{(\epsilon_r-1)^2}{(\epsilon_r+1)^2} \quad \text{eV} \]

其中 \(n\) 是主量子数，分子 0.85eV 正好是氢原子基态能量的 \(\dfrac{1}{4^2}\) 。所以镜像态也可以根据主量子数的不同来区分出不同的能级。求解过程可以在一篇文章²中查到；镜像势的表达式的推导过程详见附录。

严格地说，镜像态也是表面态的一种³。一般而言，镜像态在真空能级以下 1eV 以内， DFT 算出的 IPS 能级可能会超过真空能级，但在实际上是不太可能的，即使真的有，实验上也不大能测得到。

计算过程

事实上计算出镜像态，并不需要改太多的东西。下面在介绍如何设置计算参数的同时以 Ag(111) 上吸附苯分子为例阐述如何从结果中分析是否存在 IPS 。

计算参数

这里使用的晶格是 Ag(111) 的 \(3\times3\) 表面，上表面放置了一个苯分子，结构如图：

Figure 2: Benzene on Ag(111)

足够的空带

如果体系比较小， VASP 默认取的 NBANDS 是足够找到 IPS 的；但当体系特别大的时候，默认的 NBANDS 可能不太会覆盖到 IPS ，这时需要增加 NBANDS ，一般加到真空能级以上 3eV 就足够了，实际上这里只是需要 VASP 能较为精确地算对真空能级附近的态，而标号接近 NBANDS 的能带不准确，表现在能带图上就是色散关系就像被生生截断了一样，且呈锯齿状；此外，如果在实空间展开这个态会发现这个它像是随机生成的一样，没用使用价值分布。关于真空能级怎么算，详见之前的博文。

这里使用的体系里因为原子数比较适中，不用额外增加 NBANDS 。

足够的真空层

镜像态在真空层中，因此需要足够的真空层来容纳它，一般而言 30A 真空层可能还不算够。但要注意 VASP 在算高度超过 70A 的晶格时会很难收敛。

这里使用的体系加了 50A 的真空层，已经足够放下上表面的 IPS 。

偶极校正

如果 Slab 表面没有吸附其它原子/分子，则不必对体系进行偶极校正，否则需要校正，具体过程参见之前的博文。

偶极校正效果如图：

Figure 3: Benzene on Ag111 偶极校正后功函数图像

验证计算结果

这里的「验证」与其说是验证，不如说是寻找。前面提到， IPS 是一种相对「弥散」的态，它「弥散」的性质决定了怎么去 Identify IPS 。这里总结了几种「找」 IPS 的方法。

PDOS 法

一个态比较「弥散」说明它的局域性（locality）比较低，反映在物理图像里就是它投影在原子上的态比较少。因此我们可以在通过不同能带在原子上的投影大小来判断它是否是 IPS。

幸运地是 VASP 可以通过 LORBIT = .TRUE. 来输出 PROCAR 文件，它包含了每个能带在所有原子上的投影大小，顺便说一句， PROCAR 还包含不同角动量的投影大小。

先结构弛豫，再进行自恰计算得到 PROCAR 后，可以通过以下方法查看这个态在所有原子上的投影之和：

打开 PROCAR ，定位到真空能级 ⁴ 附近 \(\Gamma\) 点的能带

band    35 # energy    3.23957699 # occ.  0.00000000

ion      s     py     pz     px    dxy    dyz    dz2    dxz  x2-y2    tot
    1  0.002  0.000  0.000  0.000  0.000  0.000  0.002  0.000  0.000  0.004
    2  0.001  0.000  0.001  0.000  0.000  0.000  0.000  0.000  0.000  0.002
    ......
tot    0.005  0.000  0.004  0.000  0.000  0.000  0.004  0.000  0.000  0.013

看最后一行 tot 0.005 ... ，最右边也有一个 tot ，两者交叉的的值 0.013 即为这条能带在整个系统上的投影大小，换言之，局域度的大小。那么这个值越小则它是 IPS 的可能性越高。比如上面的能带 PDOS 中整体的 PDOS 之和只有 0.013 ，说明它的局域度很小，那么这个态非常弥散，有可能是 IPS 。

实空间分布法

仅仅是通过能带的 PDOS 还不足以确认这条带是不是 IPS ，有些费米能级附近的带总体 PDOS 也很小，但不是 IPS 。这时就需要其它方法来看了，比如本节要介绍的实空间分布法。

IPS 在实空间的分布特征相当明显：

它们在表面以外，并且随着主量子数的升高有着对应个数的波包；
每个波包对应的空间分布呈明显的近自由电子态的特征。

如下图⁵所示：

Figure 4: IPS 的实空间分布曲线，最下面的曲线是镜像势的曲线。

上面图中 \(n=1\) 的 IPS 只有一个波包， \(n=2\) 时有两个波包， \(n=3\) 时有三个，以此类推下去……

对于第一个特征，我们可以对波函数的模平方作 \(z\) 方向上的分布，数出表面外有多少个峰，注意区分 Slab 的上表面和下表面，只有上表面的波包应该被计入在内。

在 Benzene on Ag(111) 体系中，对应的 IPS 实空间分布曲线如下：

Figure 5: Benzene on Ag(111) 表面 IPS 的实空间分布曲线

如果只看 \(z\) 方向上的波函数觉得不放心，可以把某条带在实空间的分布画出来，如果它在真空中，并且上下表面近似为平面，即在水平方向上为近自由电子，也就可认为它是 IPS ，如下图所示：

Figure 6: Benzene on Ag(111) 体系 IPS 的实空间分布，这里每张图的等值面 Level 不同，以体现出对应数量的波包

实际上，图上所标 \(n=4\) 的曲线并不真的是 IPS ，它的能量在真空能级以上，并且它的能量也不符合 \(\dfrac{1}{n^2}\) 的规律。如果仔细验证的话， \(n=1,2,3\) 的能量也并不符合这个规律，这就是 DFT 理论的局限所致，想要再算得更准，需要更大的代价。

能带法

以上是在单点能静态计算的基础上进行的分析，如果已经画出了这个体系的能带图，从能带图上可以更加清晰地反映出 IPS 的特征。

能带图的横坐标量纲是动量，纵坐标是能量。一个自由电子的能量全部由动能贡献，因此它的能量与动量的关系就是

\[ E = E_k = \frac{p^2}{2m} = \frac{g^2}{2m_e} \]

\(E\) 与 \(g\) 呈二次函数式色散关系，那么只要某个带的色散关系与抛物线相似，就有理由认为某能带可能是 IPS ，比如下面的图中 4 eV 附近 \(\Gamma\) 点的能带明显呈抛物线色散关系，而它们也确实算是 IPS 。

如果更有耐心的话，可以算一下那几条带的相对有效质量，如果接近 1 ，就可以很明确地说明这几条带是 IPS ，可惜本人不太想再算这个（实际就是懒），这个就算作「读者自证不难」吧2333。

附录

镜像势表达式的推导

这里更一般地推导一下两种介质界面处镜像势的表达式，过程参考自⁶。

假设有两种介质 1 和 2，它们的介电常数分别为 \(\epsilon_1\) 和 \(\epsilon_2\) ，有电荷 \(q\) 在介质 1 中，如下图所示：

现在将问题分成两部分来看：分别计算介质 1 和介质 2 中电场强度。

在介质 1 中任取一点 \(P\) ，同时认为 \(q\) 的镜像电荷等效带电量为 \(q'\) ，则 \(P\) 点的受力如下图所示

此处的电场强度为

\[\begin{aligned} V_1 &={} \frac{1}{4\pi \epsilon_1} \left( \frac{q}{R_1} + \frac{q'}{R_2} \right) \newline R_1 &={} \sqrt{(z-d)^2 + r^2} \newline R_2 &={} \sqrt{(z+d)^2 + r^2} \newline E_z &={} -\frac{\partial V_1}{\partial z} = \frac{1}{4\pi\epsilon_1} \left[ \frac{q(z-d)}{R_1^3} + \frac{q'(z-d)}{R_2^3} \right] \newline E_r &={} -\frac{\partial V_1}{\partial r} = \frac{1}{4\pi\epsilon_1} \left[ \frac{qr}{R_1^3} + \frac{q' r}{R_2^3} \right] \newline \end{aligned}\]

现在考虑介质 2 中的电场强度，由于经过一个介面，介电常数分布发生了改变，所以在介质 2 中所感受到的原来电荷的等效电荷为 \(q''\) 。

P 点的电场强度可以计算出来：

\[\begin{aligned} V_2 &={} \frac{1}{4\pi\epsilon_2} \frac{q''}{R_3} \newline R_3 &={} \sqrt{(z-d)^2 + r^2} \newline E_z^{(2)} &={} -\frac{\partial V_2}{\partial z} = \frac{1}{4\pi\epsilon_2} \frac{q'' (z-d)}{R_3^3} \newline E_r^{(2)} &={} -\frac{\partial V_2}{\partial r} = \frac{1}{4\pi\epsilon_2} \frac{q'' r}{R_3^3} \newline \end{aligned}\]

在界面处应用导体介质界面上的边界条件：

\[\begin{cases} z = 0 \implies R_1 = R_2 = R_3 = R \newline D_z^{(1)} = D_z^{(2)} \newline E_r^{(1)} = E_r^{(2)} \newline \end{cases}\]

即：

\[\begin{aligned} \epsilon_1 E_z^{(1)} & = {} \epsilon_2 E_z^{(2)} \newline \implies \epsilon_1 \frac{1}{4\pi\epsilon_1} \frac{(q-q')d}{R^3} & = {} \epsilon_2 \frac{1}{4\pi\epsilon_2} \frac{q'' d}{R^3} \newline \implies q - q' &={} q'' \end{aligned}\]

\[\begin{aligned} E_r^{(1)} &={} E_r^{(2)} \newline \implies \frac{1}{4\pi\epsilon_1} \frac{(q+q')r}{R^3} &={} \frac{1}{4\pi\epsilon_2} \frac{q'' r}{R^2} \newline \implies \frac{q+q'}{\epsilon_1} &={} \frac{q''}{\epsilon_2} \end{aligned}\]

联立上面两式，可以得到

\[ q' = -\frac{\epsilon_2 - \epsilon_1}{\epsilon_2 + \epsilon_1} q \]

如果用相对介电常数 \(\epsilon_r = \dfrac{\epsilon_2}{\epsilon_1}\) ，上面式子还能简化为

\[ q' = -\frac{\epsilon_r - 1}{\epsilon_r + 1} q = -\beta q \]

这就是前文中镜像电荷表达式中 \(\beta\) 的来源。可以看出，如果 \(\epsilon_r < 1\) ，镜像电荷的符号与原来电荷相同。

电荷 \(q\) 的受力以及势能表达式：

\[\begin{aligned} F(z) &={} -\frac{\beta q^2}{4\pi \epsilon_0 (2z)^2} \quad \beta = \frac{\epsilon_r-1}{\epsilon_r+1} \newline V(z) &={} -\frac{\beta q^2}{4\pi \epsilon_r \cdot 4z} \end{aligned}\]

文中第一节的表达式得证。

Wikipedia Surface States item https://en.wikipedia.org/wiki/Surface_states ↩︎
One-dimensional hydrogen atom https://royalsocietypublishing.org/doi/10.1098/rspa.2015.0534 ↩︎
Image potential surface states https://iopscience.iop.org/article/10.1088/0031-8949/36/4/009/pdf ↩︎
真空能级可以在 OUTCAR 里找到（ grep vacuum OUTCAR ） ↩︎
图片来自 Image-potential-induced states at metal surfaces https://www.sciencedirect.com/science/article/pii/S0368204802001500 ↩︎
Classical Electrodynamics, From Image Charges to the Photon Mass and Magnetic monopoles, Francesco Lacava https://www.springer.com/gp/book/9783319394732 ↩︎

VASP 偶极校正及功函数的计算

Fri, 23 Apr 2021 16:44:00 +0800

Table of Contents

水文一篇，介绍了如何用 VASP 添加偶极校正参数、计算 Slab 体系的功函数，以及如何找真空能级。

概念解释

功函数

将一个固体内部的电子移动到真空所需的能量。（类似于光电效应方程中的逸出功）。

真空能级

固体表面外真空中自由电子所具有的能量。换句话说，电子跑出固体表面并达到这个能级后即可认为它自由免费了。

偶极校正

因 VASP 所适用的体系是周期性体系，使用它来模拟实验中的 Slab 模型时会取一个相当大的真空层来隔绝相信两个周期中 Slab 的相互作用。理想情况下，真空层中的功函数应当是一条水平的直线（函数值为定值）。但如果表面的两侧并非对称，即其中一侧吸附了分子时，这两侧的功函数存在差异，此时如果不进行偶极校正，真空中的功函数会是一条斜线；而经过偶极校正后，功函数会出现一个阶梯，阶梯两侧附近的曲接近水平。下图¹是一个例子。

Figure 1: DFT 曲线为未经过偶极校正的功函数， DFT-DC 曲线是经过偶极校正后的功函数

如何计算

偶极校正

VASP 中直接使用 LDIPOL 和 IDPOL 即可开启它的偶极校正功能。

LDIPOL = .TRUE. 表示打开偶极校正；
IDIPOL = 3 表示偶极校正所修正的方向为第 3 个晶格矢量方向对应的方向，一般来说就是 \(z\) 轴；
DIPOL = <3 float values> 表示体系的中心，以分数坐标表示；

上面几个 Flag 中一般来说 DIPOL 不用填，因为 VASP 手册中²有一句

If the flag is not set, VASP determines, where the charge density averaged over one plane drops to a minimum and calculates the center of the charge distribution by adding half of the lattice vector perpendicular to the plane where the charge density has a minimum (this is a rather reliable approach for orthorhombic cells).

不过有时不填它会导致体系非常难以收敛，如果遇到这各情况，最好还是手动算一下所有原子 \(z\) 坐标的平均值，然后 DIPOL = 0.5 0.5 <averaged z> ，此时修正效果可能并不好，读者需要：

打开偶极校正和 DIPOL = 0.5 0.5 <averaged z> ，并弛豫结构到稳定；
关闭 DIPOL ，并弛豫到结构稳定；
关闭 DIPOL ，打开 LVHAR = .TRUE. ，并做静态计算，得到功函数；

偶极校正的标准是功函数出现台阶，并且台阶两边为水平，如果画出的功函数图不是这样，就要考虑调整参数了。

功函数

在 VASP 中 LVHAR ³参数可以使 VASP 输出体系的功函数文件 LOCPOT 。LOCPOT 文件本身是 Volumetric data ，它的格式与 CHGCAR 一样⁴。一般而言，用户关心的功函数是垂直于表面方向上的数据，因此在得到 LOCPOT 后需要对它做一点工作，即对 \(xy\) 平面内的数据做平均，然后乘以晶胞的体积，就得到我们需要的功函数信息。这里给出一个脚本⁵来完成这项工作：

def locpot_mean(fname="LOCPOT", axis='z', savefile='locpot.dat', outcar="OUTCAR"):
    '''
    Reads the LOCPOT file and calculate the average potential along `axis`.
     @in: See function argument.
    @out:
          - xvals: grid data along selected axis;
          - mean: averaged potential corresponding to `xvals`.
    '''
    def get_efermi(outcar="OUTCAR"):
        if not os.path.isfile(outcar):
            logger.warning("OUTCAR file not found. E-fermi set to 0.0eV")
            return None
        txt = open(outcar).read()
        efermi = re.search(r'E-fermi :\s*([-+]?[0-9]+[.]?[0-9]*([eE][-+]?[0-9]+)?)', txt).groups()[0]
        logger.info("Found E-fermi = {}".format(efermi))
        return float(efermi)

    logger.info("Loading LOCPOT file {}".format(fname))
    locd = VaspChargeDensity(fname)
    cell = locd.atoms[0].cell
    latlens = np.linalg.norm(cell, axis=1)
    vol = np.linalg.det(cell)

    iaxis = ['x', 'y', 'z'].index(axis.lower())
    axes = [0, 1, 2]
    axes.remove(iaxis)
    axes = tuple(axes)

    locpot = locd.chg[0]
    # must multiply with cell volume, similar to CHGCAR
    logger.info("Calculating workfunction along {} axis".format(axis))
    mean = np.mean(locpot, axes) * vol

    xvals = np.linspace(0, latlens[iaxis], locpot.shape[iaxis])

    # save to 'locpot.dat'
    efermi = get_efermi(outcar)
    logger.info("Saving raw data to {}".format(savefile))
    if efermi is None:
        np.savetxt(savefile, np.c_[xvals, mean],
                   fmt='%13.5f', header='Distance(A) Potential(eV) # E-fermi not corrected')
    else:
        mean -= efermi
        np.savetxt(savefile, np.c_[xvals, mean],
                   fmt='%13.5f', header='Distance(A) Potential(eV) # E-fermi shifted to 0.0eV')

完整的脚本文件已经放 Gist⁵ 上，当然你也可以直接点击它来下载。运行这个脚本后得到的 Workfunction.pdf 和 locpot.dat 就是 \(z\) 方向上的功函数信息。

Figure 2: Workfunction.png 示例

真空能级

前面已经提到，真空能级可以读取 locpot.dat 真空部分的数据得到，其实当你打开 LVHAR 时，它也可以通过读取 OUTCAR 得到，比如

1
2

$ grep vacuum OUTCAR
 vacuum level on the upper side and lower side of the slab         2.807         3.188

这里的 upper side vacuum level 是指 Slab 上表面的真空能级（图 2 中 30A 处的平台）， lower side vacuum level 自然就是下表面的真空能级了（图 2 中 35A 处的平台）。

需要注意的是，从 OUTCAR 中 grep 出的真空能级没有经过费米能级修正，它需要减去 OUTCAR 中的 E-fermi 才是实验中测得的功函数的值。所幸的是 plot-workfunc.py 已经做了这个工作，用 locpot.dat 画出来的图就对应实验所测结果。

图源： http://exciting-code.org/nitrogen-dipole-correction ↩︎
https://www.vasp.at/wiki/index.php/DIPOL ↩︎
在 VASP 5.2.12 之前的版本中 LVTOT 输出的文件是静电势的贡献；但在 VASP 5.2.12 及之后的版本中，交换关联势的贡献也会被写入 LOCPOT 中， LVHAR 输出的部分才是真正静电势的贡献，也就是我们想要的部分； ↩︎
CHGCAR 的格式请见 VASP 手册 https://www.vasp.at/wiki/index.php/CHGCAR ； ↩︎
完整脚本见 https://gist.github.com/Ionizing/1ac92f98e8b00a1cf6f16bd57694ff03 。 ↩︎

VASP 收敛性测试的小脚本

Fri, 16 Apr 2021 20:57:00 +0800

Table of Contents

一般而言，在使用 VASP 计算体系之前都需要对一些参数做收敛性测试，侯老师¹ 曾写过一本VASP 入门手册，里面给了一些测试计算参数的小脚本，这里我也给出一些我经常用的收敛性测试脚本，权当抛砖引玉了。

本文提供的测试脚本可以写进提交任务的脚本中，进而充分利用超算上多核、多节点的计算资源。需要注意的是，这些脚本本身并不产生 VASP 的输入文件，而是在已有的文件基础上进行修改。

`SIGMA` 的测试

和上面的使用前提一样， INCAR 应提前准备好。 SIGMA 收敛的标准通常是 dE 绝对值小于 1.0meV/atom 。

#!/bin/bash
#SBATCH xx
...

set -e
set -o pipefail

VASP_EXEC="srun /path/to/vasp"  # "mpirun -np xxx" is also ok

date >> sigma.txt
for i in 0.8 0.5 0.3 0.1 0.08 0.05 ; do
    echo
    sed -i "s/^.*\\bSIGMA\\b.*$/        SIGMA = $i" INCAR
    eval ${VASP_EXEC}
    TS=$(grep "EENTRO" OUTCAR | tail -1 | awk '{print $5}')
    echo "$i    $TS" >> sigma.txt
done

echo "NIONS = " $(grep NIONS OUTCAR | awk '{print $12}') >> sigma.txt

`ENCUT` 的测试

使用前请先写好一个 INCAR ，并确保里面包含 ENCUT 字段，且 ENCUT 单独占一行（否则同一行内的其它参数会被舍去）。通常而言，达到收敛的标志是相邻两次迭代的能量小于 1.0meV/atom 。

#!/bin/bash
#SBATCH xx
...

set -e
set -o pipefail

VASP_EXEC="srun /path/to/vasp"  # "mpirun -np xxx" is also ok

date >> encut.txt
for i in {200..500..50}; do
    sed -i "s/^.*\\bENCUT\\b.*$/        ENCUT = $i" INCAR
    eval ${VASP_EXEC}
    E=$(grep TOTEN OUTCAR | tail -1 | awk '{printf "%12.6f", $5}')  # Extract TOTEN from OUTCAR
    echo "$i    $E" >> encut.txt
done

echo "NIONS = " $(grep NIONS OUTCAR | awk '{print $12}') >> encut.txt

晶格参数的测试

晶格常数的测试

执行这个测试需要准备好 POSCAR ，这个测试不依赖 ASE 等包，因为它实质上是在更改 POSCAR 第二行的 scale factor 。这个测试只是相对粗糙的测试，因此这里就直接在原位覆盖前一次的计算结果了。

#!/bin/bash
#SBATCH xx
...

set -e
set -o pipefail

VASP_EXEC="srun /path/to/vasp"  # "mpirun -np xxx" is also ok

date >> a.txt
for i in $(seq 0.99 0.001 1.01)
do
  sed -i "2c $i" POSCAR
  echo -e "a = $i angstrom"
  eval ${VASP_EXEC}
  E=`grep "TOTEN" OUTCAR | tail -1 | awk '{printf "%12.6f", $5 }'`
  V=`grep "volume" OUTCAR | tail -1 | awk '{printf "%12.4f", $5}'`
  printf "a = %6.3f Vol = %10.4f Energy = %18.10f\n" $i $V $E >> a.txt
  tail -1 a.txt
done
echo -e "\n\n" >> a.txt#+end_src

晶格长度的测试

在测试晶格的角度、长度时就不得不使用其它包了，Python 的 ASE 包提供了相对完善的基础设施，这里在使用它来辅助完成晶格测试的工作。另外，在测试 Slab 的真空层厚度时也可以使用这个脚本²。

#!/usr/bin/env python3

import os
from ase.io import read as poscar_reader

poscar = poscar_reader("POSCAR")
cell = poscar.get_cell().copy()

for i in range(1, 7):
    cell[-1, -1] += 5.0             # Increase length along z axis by 5 angstroms each time
    poscar.set_cell(cell)
    dirname = "{:02}".format(i*5)
    if not os.path.exists(dirname):
        os.mkdir(dirname)           # create directories for each test
    poscar.write(dirname + "/POSCAR", vasp5=True, direct=True)
    for infile in ['INCAR', 'POTCAR', 'KPOINTS', 'sub_vasp_tahoma']:
        abspath = os.path.abspath(infile)
        os.symlink(abspath, dirname + "/" + infile)
        pass
    print("POSCAR saved in {}".format(dirname + "/POSCAR"))
    pass

用户可以根据自己需要随意更改晶格的参数，具体的需求可以通过阅读 ASE 的文档³来实现，这里就不一一列举了。

Slab 衬底层数的测试

一般而言，结构建模都是在 Materials Studio 上完成的（我现在也是如此），但如果有对 Slab 衬底做收敛性测试的需求，还是要借助一下 ASE ，它也内置一了些常见的 Slab 。

下面是一个生成不同层数 Ag(111) Slab 的脚本：

#!/usr/bin/env python3

import os
import numpy as np
from ase.build import fcc111
from ase.constraints import FixAtoms

for i in np.arange(1, 9):
    numstr = str(i)

    # generate 1x1 slab along a and b axis, this slab has `i` layers
    # vacuum is 20 angstrom
    slab = fcc111("Ag", size=(1, 1, i), vacuum=20)

    # Relax the first 2 layers and fix the others.
    c = FixAtoms(mask=[atom.tag > 2 for atom in slab])

    # Apply the constraint
    slab.set_constraint(c)
    print(slab)
    if not os.path.exists(numstr):
        os.makedirs(numstr+"/opt")
        os.makedirs(numstr+"/band")
        pass
    slab.write(numstr+"/opt/POSCAR", vasp5=True, direct=True)
    pass

对于其它金属， ASE 也有支持，详细说明请看它的文档⁴。

https://github.com/orivenlikon/vaspDoc/blob/master/%5Bmuchong.com%5Dvasp%E5%85%A5%E9%97%A8%E6%8C%87%E5%8D%97-%E5%A4%8D%E6%97%A6-%E4%BE%AF%E6%9F%B1%E5%B3%B0.pdf ↩︎
这个脚本要求晶格的 c 轴垂直于 a 轴和 b 轴 ↩︎
https://wiki.fysik.dtu.dk/ase/ase/atoms.html 和 https://wiki.fysik.dtu.dk/ase/ase/geometry.html ↩︎
https://wiki.fysik.dtu.dk/ase/ase/build/build.html ↩︎

记一次 Julia 代码性能优化过程

Fri, 16 Apr 2021 13:06:00 +0800

Table of Contents

这是和某三爷讨论后对交流内容的整理。

众所周知， Julia 是一种高级通用动态编程语言，它专为科学计算而生。为了方便科研人员使用，它的语法被设计得很像 MATLAB ，但比 MATLAB 更合理（譬如数组引用使用 [] ，而不是 () ）。作为一门很年轻的语言，它吸收了前辈们的很多优点，也有着自己的特色，但最受人青睐的一点在于：尽管它是一门动态语言，却宣称拥有 C/C++ 一般的性能。一般而言，动态语言的表现能力更为出色，能用更少的代码做更多的事，开发效率高；而静态语言的编译器后端更容易优化，运行效率高。Julia 有动态性，开发效率毋庸置疑，一些测评也显示 Julia 确实拥有很强的性能，但这是否意味着你随手写的一段代码就能有很高并且达到预期的性能？我看未必。

运行环境

Processor	Intel Core i5 9600KF
Memory	16GB 3200MHz
OS	macOS 10.15.6
Julia	1.5.1

优化过程

原始版本¹

废话不多说，直接开始正题，先来看今天的主角²

using Rmath;
using BenchmarkTools;

function JGibbs1(N::Int, thin::Int)
    mat = zeros(Float64, N, 2)
    x   = 0.
    y   = 0.
    for i = 1:N
        for j = 1:thin
            x = rgamma(1, 3, 1/(y*y + 4))[1]
            y = rnorm(1, 1/(x+1), 1/sqrt(2(x + 1)))[1]
        end
        mat[i,:] = [x,y]
    end
    mat
end;

@btime JGibbs1(20000, 200);

这是一段关于 Gibbs 采样的代码，它主要由两个循环组成，外部循环一次产生两个值，内部循环是迭代式的，即下一次循环要用到上次循环的结果。很明显它引入了 R 的库，并用 R 的 rgamma 和 rnorm 实现，那么它的性能是怎样的呢？

`1`	`501.798 ms (8020002 allocations: 734.56 MiB)`

根据原文的说法，它的性能已经比 Rgibbs 快 17 倍，比 RCgibbs 快 13 倍，已经是比较令人满意的结果了。

使用 C-ffi 的 `rgamma` 与 `rnorm`¹

由于直接用 R 写的代码可能并不是最快的，而且它还在内层循环里，所以我们有理由相信使用 C-ffi³ 版的 rgamma 与 rnorm 会更快。

using Rmath
import Rmath: libRmath
using BenchmarkTools
function JGibbs2(N::Int, thin::Int)
    mat = zeros(Float64, N, 2)
    x   = 0.
    y   = 0.
    for i = 1:N
        for j = 1:thin
            x = ccall((:rgamma, libRmath), Float64, (Float64, Float64), 3., 1/(y*y + 4))
            y = ccall((:rnorm, libRmath), Float64, (Float64, Float64), 1/(x+1), 1/sqrt(2*(x + 1)))
        end
        mat[i,:] = [x,y]
    end
    mat
end

@btime JGibbs2(20000, 200);

1
2

JGibbs2 (generic function with 1 method)
  259.387 ms (20002 allocations: 2.14 MiB)

果然，使用 C-ffi 版的函数后性能又提升了一倍！

去除外部依赖¹

尽管使用 C 的实现后， JGibbs 性能提升巨大，但依赖外部库多少有点让人感觉不爽，毕竟它和 Julia 所宣称的高性能关系不是很大（核心部分是 C 的贡献，而不是 Julia）。既然 Julia 也是高性能语言，何不拿纯 Julia 写一个 JGibbs 来比比？

Julia 是为科学计算而生，它的社区维护了一个统计学库 Distributions ，里面包含了 gamma 与 norm 分布的函数，可以用来替换 rgamma 和 rnorm ，写完之后是这个样子：

using BenchmarkTools;
using Distributions;

function JGibbs3(N::Int, thin::Int)
    mat = zeros(Float64, N, 2)
    x   = 0.
    y   = 0.
    for i = 1:N
        for j = 1:thin
            x = rand(Gamma(3, 1/(y^2 + 4)), 1)[1]
            y = rand(Normal(1/(x + 1), 1/sqrt(2*(x + 1))), 1)[1]
        end
        mat[i,:] = [x,y]
    end
    mat
end

@btime JGibbs3(20000, 200);

1
2

JGibbs3 (generic function with 1 method)
  550.624 ms (8020002 allocations: 734.56 MiB)

咦？看起来它还没有使用 R-ffi 的函数快！

那么问题出在哪呢？仔细看结果，除了时间之外还有两个数据，一个是执行一次该函数时所分配内存的次数，另一个是函数执行期间分配内存的总量。我们回头看一下使用 C-ffi 的版本，它的测试结果显示除了性能更强外，内存分配的次数和总量也更少！而且 8020002 恰好是 20002 的 400 倍左右，正好是 thin=200 的 2 倍。据此，我们可以猜想，在 for j=1:thin ... end 内部存在不必要的内存分配。

下面来进行验证。

内存分配情况分析

取出循环内的一行代码，对它进行 profile ：

using BenchmarkTools;
using Distributions;

@btime rand(Gamma(1.0, 1.0), 1)[1];

`1`	`39.136 ns (1 allocation: 96 bytes)`

奇怪，一个只返回一个 Float64 值的函数怎么会存在内存分配？仔细看 [1] 这个细节，问题可能出在这里。通过查看文档，发现 rand(Gamma(...), 1) 中最后一个参数表示返回一个一维的 Array ，并且 Array 的大小是 1 ：

using BenchmarkTools;
using Distributions;

@btime rand(Gamma(1.0, 1.0), 1)

1
2
3

  37.541 ns (1 allocation: 96 bytes)
1-element Array{Float64,1}:
 0.2929698750637693

一个 Float64 的值有 64 位，共 8 字节（bytes），而刚刚代码中所返回只有一个 Float64 元素的 Array 竟然有 96 字节！既然我们每次只需要返回一个值，那为什么要画蛇添足去生成一个 Array 呢，直接调用只生成一个值的原型不好吗？

using BenchmarkTools;
using Distributions;

@btime rand(Gamma(1.0, 1.0), 1)
@btime rand(Gamma(1.0, 1.0))

  37.217 ns (1 allocation: 96 bytes)
1-element Array{Float64,1}:
 0.9938638399122478
  8.116 ns (0 allocations: 0 bytes)
1.8038508272928604

看，直接使用 rand(Gamma(...)) 耗时只有 rand(Gamma(...), 1) 的 22% ，并且内存的分配是 0 ！

有了这些结论，我们对 JGibbs3 修改后，有了下面的代码。

去除内层循环的内存分配

using BenchmarkTools;
using Distributions;

function JGibbs4(N::Int, thin::Int)
    mat = zeros(Float64, N, 2)
    x   = 0.
    y   = 0.
    for i = 1:N
        for j = 1:thin
            x = rand(Gamma(3, 1/(y*y + 4)))
            y = rand(Normal(1/(x + 1), 1/sqrt(2*(x + 1))))
        end
        mat[i,:] = [x,y]
    end
    mat
end

@btime JGibbs4(20000, 200);

1
2

JGibbs4 (generic function with 1 method)
  251.144 ms (20002 allocations: 2.14 MiB)

这个耗时结果就正常多了，而且比调用 C-ffi 的版本还快了一丢丢；内存的分配也没那么夸张了。

去除外层循环的内存分配

但这并不是它的性能极限：它依然有 20002 次的内存分配。仔细观察外层循环部分，只有一个 mat[i,:] = [x,y] ，通常人们会认为编译器把它循环展开，不涉及内存分配，但事实并非如此：

using BenchmarkTools

mat = zeros(Int, 2, 2);
@btime mat[1, :] = [1, 2];
@btime mat[:, 1] = [1, 2];
@btime begin
    mat[1, 1] = 1;
    mat[1, 2] = 2;
    end;
@btime begin
    mat[1, 1] = 1;
    mat[2, 1] = 2;
    end;

259.485 ns (2 allocations: 112 bytes)
220.621 ns (2 allocations: 112 bytes)
28.665 ns (0 allocations: 0 bytes)
27.603 ns (0 allocations: 0 bytes)

我们可以得出三个结论：

在使用切片赋值时会涉及内存分配，直接使用循环则不会；
小矩阵赋值时使用循环甚至手动展开循环性能更高；
Julia 的 Array 使用列主序，对第一个维度操作比对其它维度操作性能更高，但提升幅度有限。

于是我们把 JGibbs4 中外层循环的矩阵赋值展开，得到 JGibbs5

using BenchmarkTools;
using Distributions;

function JGibbs5(N::Int, thin::Int)
    mat = zeros(Float64, N, 2)
    x   = 0.
    y   = 0.
    for i = 1:N
        for j = 1:thin
            x = rand(Gamma(3, 1/(y*y + 4)))
            y = rand(Normal(1/(x + 1), 1/sqrt(2*(x + 1))))
        end
        mat[i,1] = x;
        mat[i,2] = y;
    end
    mat
end

@btime JGibbs5(20000, 200);

1
2

JGibbs5 (generic function with 1 method)
  229.861 ms (2 allocations: 312.58 KiB)

它比 JGibbs4 又快了 20ms ！而且其中内存分配只有两次，已经相当令人满意了。如果要进一步压榨它的性能潜力，我们可以交换 mat 的行列，使外层循环每次赋值时都在访问第一个维度，限于篇幅原因，这里就不展开了。

使用多线程加速

上面使用的方法都是在一个线程内操作，现在的机器普遍都用上的多核处理器，而超算上更是单节点上配备了数十个处理器，如此多的计算资源不利用好岂不是暴殄天物。

那么 JGibbs 函数能被并行化吗？答案是肯定的。

它的内层循环粒度太小，线程切换的耗时占比太高，因此内层循环不适合并行化。而外层循环的粒度适中，我们试试将它并行化。

直接使用 Threads.@threads

Julia 原生支持多线程编程，并且提供了 Threads.@threads 宏来方便对循环并行化，于是就有了下面的代码

println("nthreads = ", Threads.nthreads())

using BenchmarkTools;
using Distributions;

function JGibbs6(N::Int, thin::Int)
    mat = zeros(Float64, N, 2)
    x   = 0.
    y   = 0.
    Threads.@threads for i = 1:N
        for j = 1:thin
            x = rand(Gamma(3, 1/(y*y + 4)))
            y = rand(Normal(1/(x + 1), 1/sqrt(2*(x + 1))))
        end
        mat[i,1] = x;
        mat[i,2] = y;
    end
    mat
end

@btime JGibbs6(20000, 200);

1
2
3

nthreads = 6
JGibbs6 (generic function with 1 method)
  420.151 ms (52000035 allocations: 915.84 MiB)

⁴

这个结果很离谱。先不谈运行时间，单看它的内存分配量就知道它绝对是有问题的（至于为什么多出来这么多的内存分配，我也还在寻找原因，如果您有什么见解，请务必发邮件告诉我 ^_^）， Julia 一共开了 6 个线程来加速，但结果显示它反而使运行效率降低了，问题出在哪呢？仔细看代码

    x   = 0.
    y   = 0.
    Threads.@threads for i = 1:N
        for j = 1:thin
            x = rand(Gamma(3, 1/(y*y + 4)))
            y = rand(Normal(1/(x + 1), 1/sqrt(2*(x + 1))))
        end
        ...
    end

每个线程内，都要对全局变量 x 和 y 进行修改，并且还要读取它们的值，这显然存在竞争的现象。那如果把 x 和 y 移动到每个线程内部定义呢？

println("nthreads = ", Threads.nthreads())

using BenchmarkTools;
using Distributions;

function JGibbs6_1(N::Int, thin::Int)
    mat = zeros(Float64, N, 2)
    Threads.@threads for i = 1:N
        x   = rand()
        y   = rand()
        for j = 1:thin
            x = rand(Gamma(3, 1/(y*y + 4)))
            y = rand(Normal(1/(x + 1), 1/sqrt(2*(x + 1))))
        end
        mat[i,1] = x;
        mat[i,2] = y;
    end
    mat
end

@btime JGibbs6_1(20000, 200);

1
2
3

nthreads = 6
JGibbs6_1 (generic function with 1 method)
  39.926 ms (33 allocations: 316.75 KiB)

这个结果相当令人满意了，内存的分配降低很多，看来读写全局的变量对并发程序性能影响还是不容忽略！

对外层循环分组后并行

除了直接用 @threads ，我们还可以手动对外部循环分组嘛，然后每个线程分配到一小段连续的外层循环，相当于粒度更大。

Iterators 提供了对 Array 分组的方法：

help?> Iterators.partition
  partition(collection, n)

  Iterate over a collection n elements at a time.

  Examples
  ≡≡≡≡≡≡≡≡≡≡

  julia> collect(Iterators.partition([1,2,3,4,5], 2))
  3-element Array{SubArray{Int64,1,Array{Int64,1},Tuple{UnitRange{Int64}},true},1}:
   [1, 2]
   [3, 4]
   [5]

利用这个函数，我们对外层循环的下标分组，然后每个线程只操作一组下标，这样有效避免了数据竞争发生。

using BenchmarkTools;
using Distributions;

println("nthreads = ", Threads.nthreads())

function JGibbs7(N::Int, thin::Int)
  nt = Threads.nthreads()

  # mat = zeros(Float64, N, 2)
  mat = zeros(Float64, N, 2)

  # partition
  parts = Iterators.partition(1:N, N ÷ Threads.nthreads() + 1) |> collect

  Threads.@threads for p in parts
    x   = 0.
    y   = 0.
    for i in p
      for j in 1:thin
        x = rand(Gamma(3, 1/(y^2 + 4)))
        y = rand(Normal(1/(x + 1), 1/sqrt(2*(x + 1))))
      end
      mat[i,1] = x
      mat[i,2] = y
    end
  end

  mat
end

@btime JGibbs7(20000, 200);

1
2
3

nthreads = 6
JGibbs7 (generic function with 1 method)
  41.631 ms (34 allocations: 316.91 KiB)

这个结果和 JGibbs6_1 相差不大，都是已经充分利用了 6 个线程的计算资源。

总结

本文从一名用户的角度，浅显地阐述了如何对一个函数进行优化，以及如何使用各类工具来帮助我们分析程序的运行状况。我得出以下几个结论，供大家参考：

使用纯 Julia 编写的程序性能的上限很高，完全不输于调用 FFI ，因此大家对此不应有过多的顾虑，直接用就完事了；
尽管我们认为处理器的计算是耗时大头，程序运行时的内存反复分配也可能成为程序运行的瓶颈；
在使用并发加速时应格外小心是否存在竞争的风险，能做到内聚就尽量做到内聚，否则将来总会掉到坑里；
想发挥出 Julia 真正的性能，还是需要下一些功夫的，随手一写还真不一定比其它语言快；好在 Julia 社区提供了实用的性能分析工具，大大简化了优化的流程，这一点我十分赞赏。

代码来自三爷的 gist : https://gist.github.com/MitsuhaMiyamizu/5edf031a36cfb260381a70060a3fea4a ↩︎
这里使用 BenchmarkTools 中的 @btime 而不是 @time 是因为后者并不能将代码编译的时间去掉，前者则能多次执行，取耗时最小值，有效避免了 AOT 对计时的影响。 ↩︎
ffi 即 Foreign function interface ，用于跨语言调函数，详见 https://en.wikipedia.org/wiki/Foreign_function_interface ↩︎
我在启动 julia 前对环境变量进行了修改 export JULIA_NUM_THREADS=6 ，这样 Julia 在运行时支持最大 6 个线程操作。 ↩︎

新的旅程

Wed, 14 Apr 2021 16:15:00 +0800

Table of Contents

这是回归博客写作后的第一篇文章

回归

时光荏冉，已经好久没有更新博客了，上一次写博客还是去年寒假疫情在家时期。

这一年多以来总算把与实验组合作的几个工作结束了（第一次实践使用 VASP ），这几个工作感觉能总结的地方不多，都是细节居多，但坑还是不少的。我自己的工作做了快两年了（看来平时没少摸鱼），在去年底它的进度有了 180 度转变，这还多亏了导师的嘱托，让我在补充图表时 Review 了一下之后的结果，一看就发现之前的结论完全错误，于是重新跑了一下 NAMD ，这次的结果终于符合「预期」了，但现在似乎又遇到了一些不大不小的问题，即能带交叉的处理，目测解决它又要费些时间了（而且还中间还有其它实验组的东西要做）。

说了这段时间自己在做什么，下面就该讲博客相关的东西了。

博客相关

关于博客，我这次决心将它迁移到 Hugo 框架下，配合 Org-mode 和 ox-hugo 使用，至少到现在体验挺好：

Hugo 很快，生成静态页面耗时在 ms 量级，比 Hexo 不知道高到哪里去了；
Org-mode 很强大，谁用谁知道；
私以为 Jane 主题足够简约，也留了足够的空间折腾。

近期做了些工作，我会把心得总结起来放到博客上，供自己和小伙伴们参考～

配置、模板

以下是写博客时可能要用到的一些模板/配置，仅供自己参考了。

Org-mode 中 CJK 文档的 soft space 问题，已经有人给出了解决方案¹ ：

(defun clear-single-linebreak-in-cjk-string (string)
"clear single line-break between cjk characters that is usually soft line-breaks"
(let* ((regexp "\\([\u4E00-\u9FA5]\\)\n\\([\u4E00-\u9FA5]\\)")
        (start (string-match regexp string)))
    (while start
    (setq string (replace-match "\\1\\2" nil nil string)
            start (string-match regexp string start))))
string)

(defun ox-html-clear-single-linebreak-for-cjk (string backend info)
(when (org-export-derived-backend-p backend 'html)
    (clear-single-linebreak-in-cjk-string string)))

(eval-after-load "ox"
  '(add-to-list 'org-export-filter-final-output-functions
                'ox-html-clear-single-linebreak-for-cjk))

添加链接时使用 C-c C-l ， Doom-Emacs 会提示你输入链接的 URL 和 description；
使用 Inline code 时，参考它²： src_sh[:exports code]{echo -e "test"} ；
:PROPERTIES: 中 :@cat: 定义了一个 category cat ， :foo: 定义了一个 tag foo ， :@cat:foo:bar: 则分别定义了一个 category cat ，两个 tags foo 、 bar ；
每篇文章标题前使用 S-left 或 S-right 可以切换 TODO 和 DONE 的状态；输入数学公式时，需要在 subtree 的 :PROPERTIES: 里加上 :EXPORT_HUGO_CUSTOM_FRONT_MATTER+: :markup goldmark 。

此时 \(F=ma\) 表示 inline equation ，输出 \(F=ma\) ； \[F=ma\] 表示 displaystyle equation 。（冷知识³： Orgmode 支持即时渲染公式： C-c C-x C-l 会把当前公式渲染好并以 png 的形式插入当前窗口，重复这个操作可以关闭预览）

现在试试一个稍稍复杂点的公式：

\[ \begin{aligned} \nabla \times \vec{\mathbf{B}} - \frac1c \frac{\partial\vec{\mathbf{E}}}{\partial t} & = \frac{4\pi}{c}\vec{\mathbf{j}} \newline \nabla \cdot \vec{\mathbf{E}} & = 4 \pi \rho \newline \nabla \times \vec{\mathbf{E}} + \frac1c \frac{\partial\vec{\mathbf{B}}}{\partial t} & = \vec{\mathbf{0}} \newline \nabla \cdot \vec{\mathbf{B}} & = 0 \end{aligned} \]

使用脚注来代替文献的上标⁴ ，有三种方式：
1. 声明和定义分离的脚注：在要添加脚注的地方声明 [fn:NAME] ，然后在其它地方定义这个脚注 [fn:NAME] some description here ... ；
2. 行内定义的脚注：直接使用 [fn:: some description here ... ] ，这种方法不需要命名，可谓对程序员十分友好了 23333 ；
3. 带名字的行内脚注： [fn:NAME: some description here ...] 。
在每篇博客开头的 :PROPERTIES: 部分加上下面的代码，可以让每篇文章都独立为一个目录，并把引用的文件自动复制到这个目录，避免都扔在 static 里导致可能的文件名碰撞。

:PROPERTIES:
:EXPORT_FILE_NAME: index
:EXPORT_HUGO_BUNDLE: title
:END:

图片等外部文件的引用

这一节单独列出来是因为它比数学公式还要难处理，根据 ox-hugo⁵ 的说明，现在有三种引用图片的方法：

使用相对路径：直接把图片放到 <HUGO_BASE_DIR>/static/ 里，然后引用时可以省略 <HUGO_BASE_DIR>/static/ 前缀，例如有一个文件路径是 <HUGO_BASE_DIR>/static/image/foo.png ，引用它时可以这样写： [[image/foo.png]] ；
使用绝对路径：例如有一个路径是 ~/some/path/foo.png ，引用它时可以使用 [[~/some/path/foo.png]] ，此时不光在 orgmode 里可以直接预览图片， ox-hugo 在导出时还会把它复制到 <HUGO_BASE_DIR>/static/ox-hugo/ 里并生成链接；
使用图床：现在 GitHub ， GitLab 等也可以用作图床，并且有成熟的软件来做这件事比如 PicGo⁶ 。把图片传给图床后，图床会返回一个链接，直接把它贴在 orgmode 里就能实现引用图片的效果。但之前我用七牛云的图床一段时间后七牛云直接拒绝被薅，改了域名，我也就对图床产生一些顾虑 ~~，而且使用图床后一个缺点是，它降低了每篇文章的内聚度，增加了对外部的耦合（掉个书袋233）~~ 。

因此我还是决定把图片等外部文件放在 <HUGO_BASE_DIR>/content-org/ 里，每篇文章单独建一个文件夹，然后使用相对路径引用。下面是效果展示（它使用了 [[./a-new-journey/himehina.jpeg]] ）：

使用 TikZ 配合 Orgmode 进行画图 [2021-04-29 Thu] 更新

Orgmode 原生支持内嵌 \(\LaTeX\) 代码，自然也支持用 TikZ 画图。不过如果想要在利用 TikZ 的输出嵌入到博客中，还需要一点工作要做。

输出 PNG 格式的图片

确保机器上已经安装了 ImageMagick 和 \(\LaTeX\) ；
在 config 中加入 (setq org-latex-create-formula-image-program 'imagemagick) ；

接下来就可以愉快玩耍了：

#+header: :headers '("\\usepackage{tikz}")
#+header: :results file graphics :file ./a-new-journey/test.png
#+header: :exports results
#+header: :fit yes :imoutoptions -geometry 400 :iminoptions -density 600
#+begin_src latex
\begin{tikzpicture}
\draw[->] (-3,0) -- (-2,0) arc[radius=0.5cm,start angle=-180,end angle=0]
    (-1,0) -- (1,0) arc[radius=0.5cm,start angle=180,end angle=0] (2,0) -- (3,0);
\filldraw (-1.5,0) circle[radius=1mm];
\filldraw (1.5,0) circle[radius=1mm];
\end{tikzpicture}
#+end_src

#+RESULTS:
[[file:./a-new-journey/test.png]]

Eval 这个 source block 后即可得到：

输出 SVG 格式的图片

确保机器上已经安装了 \(\LaTeX\)

接下来的工作不那么优雅，我们需要修改一下 ob-latex.el 。

因为在 Orgmode 中 Eval 代码块时 Orgmode 会自动把代码块的内容加入预告写好的 Preamble 里生成一个临时文件，但当使用 .svg 结尾的输出文件名时它的 Preamble 是这样的：

\documentclass[preview]{standalone}
\def\pgfsysdriver{pgfsys-tex4ht.def}
%% Your \usepackage here
\begin{document}
%% Your code here
\end{document}

第二行的 \def\pgfsysdriver 需要放在 \usepackage{tikz} 后，或者使用 htlatex 才能编译，但 ob-latex 使用的是 latex ，而且这个过程只会提示 PDF produced with errors ，导致输出的 SVG 是乱码。

查询 ob-latex.el 发现，这个 Preamble 是硬编码在 org-babel-execute:latex 里的：

 (defcustom org-babel-latex-preamble
   (lambda (_)
     "\\documentclass[preview]{standalone}
\\def\\pgfsysdriver{pgfsys-tex4ht.def}
 ")
   "Closure which evaluates at runtime to the LaTeX preamble."

...

          (with-temp-file tex-file
            (insert (concat
                     "\\documentclass[preview]{standalone}
\\def\\pgfsysdriver{pgfsys-tex4ht.def}
 "
                     (mapconcat (lambda (pkg)
                                  (concat "\\usepackage" pkg))

那问题就好办了，直接删掉两处 \\def\\pgfsysdriver{pgfsys-tex4ht.def} ，并重新 build （我使用的是 DoomEmacs ，运行 ~/.emacs.d/bin/doom build ），然后就可以正常导出了。

#+header: :headers '("\\usepackage{tikz}")
#+header: :results file graphics :file ./a-new-journey/test.svg
#+header: :exports results
#+header: :fit yes :imoutoptions -geometry 400 :iminoptions -density 600
#+begin_src latex
\begin{tikzpicture}
\draw[->] (-3,0) -- (-2,0) arc[radius=0.5cm,start angle=-180,end angle=0]
    (-1,0) -- (1,0) arc[radius=0.5cm,start angle=180,end angle=0] (2,0) -- (3,0);
\filldraw (-1.5,0) circle[radius=1mm];
\filldraw (1.5,0) circle[radius=1mm];
\end{tikzpicture}
#+end_src

#+RESULTS:
[[file:./a-new-journey/test.svg]]

输出以下图形：

其实看 ob-latex.el 似乎可以通过用户定义 org-babel-latex-preamble 来绕过硬编码的 Preamble ，但经过测试发现并没有起作用，如果读者有更好方案，请务必联系我。

上面测试用的 TikZ 代码圴来自 Jonny Evans⁷，同时感谢群组内⁸大佬们的帮助。

Ionizing Radiation

About

External-link

单层 TMD 材料的三能带紧束缚模型构建

引言

TMD 的晶体结构与对称性分析

TMD 的实空间结构与布里渊区

TMD 的对称性

基组的确定及对称性算符

紧束缚 Hamiltonian 的构建

坐标系与近邻原子

紧束缚模型 Hamiltonian

最近邻模型

原位项

最近邻项

能带求解

第三近邻模型

第三近邻项

次近邻项

能带求解

自旋-轨道耦合的引入

原子内 SOC 的基本形式

三能带模型中的 SOC 作用

\(L_z\) 算符

\(S_z\) 算符

考虑自旋轨道耦合后的能带

参数的拟合

目标能带

构造损失函数

程序设计和计算结果

模型的局限性

总结

待续

代码下载

致谢

一起动手算原子弹的临界质量

问题假设及目标

中子扩散方程的导出

中子扩散方程的求解

时间演化方程

空间分布方程

边界条件

临界质量的导出

小结与胡扯

如何将文件打包进 C/C++/Fortran 程序内

问题描述

解决方法

直接写 const char*

通过 inline assembly

宏+内联汇编

Fortran 的处理

小结

在 CentOS 7 上使用 Clangd 作为 C/C++ 的 LSP

基本环境要求

安装 clangd

配置 coc.nvim

利用 Const Generics 实现编译期量纲分析

什么是量纲分析

什么是 Const Generics

如何使用 Const Generics 实现量纲分析

运行期量纲分析

利用 const generics 实现编译期的量纲分析

SiUnit 的编译期运算

PhysicalQuantity 的加减法运算

PhysicalQuantity 的乘除法运算

PhysicalQuantity 的乘方开方运算

无量纲数及常系数的特殊处理

其它实现

总结

简易 DFT 玩具

理论基础

程序实现

\(\nabla^2\) 的矩阵表示

势能的表示

外场势能 \(v_\text{ext}(\mathbf r)\)

电子密度 \(\rho(\mathbf r)\)

库仑势 \(v_\text{Ha}(\mathbf r)\)

交换关联势

Hamiltonian 的构造

KS 方程的迭代求解

直接写 `const char*`

安装 `clangd`

配置 `coc.nvim`

`SiUnit` 的编译期运算

`PhysicalQuantity` 的加减法运算

`PhysicalQuantity` 的乘除法运算

`PhysicalQuantity` 的乘方开方运算

`SIGMA` 的测试

`ENCUT` 的测试

原始版本¹

使用 C-ffi 的 `rgamma` 与 `rnorm`¹

去除外部依赖¹