Primerusse Hexo https://primerusse.top/assets/pictures/icons/icon.ico https://primerusse.top/ All rights reserved 2026, Primerusse primerusse.top Primerusse's Utopia 2026-09-19T21:00:00.000Z Primerusse 1 这是什么

  写技术内容绕不开公式。用文字描述一个积分，读者得在脑子里重建；用截图贴公式，改一个符号就得重新截；用 Word 的公式编辑器，粘到网页上格式全乱。

  LaTeX 的思路是：用纯文本描述公式。比如

1
\int_0^\infty e^{-x^2}\,dx = \frac{\sqrt{\pi}}{2}

  渲染出来就是：

∫0∞e−x2 dx=π2\int_0^\infty e^{-x^2}\,dx = \frac{\sqrt{\pi}}{2}

  好处是：改公式就是改文本，能版本控制，能复制粘贴，能在任何支持 LaTeX 的地方用。

  先说明范围：这篇文章讲的是一套 LaTeX 的数学公式语法子集，不是完整的 LaTeX 排版系统。要写论文、做书籍排版那是另一回事（涉及文档类、章节、参考文献、浮动体等等）。这里只讲打数学公式够用的部分。

  全文按“基础结构 → 各类符号 → 排版细节 → 符号速查表”组织，最后附一个尽量全的符号对照表，可以当手册用。

2 两种模式

  公式有两种写法，区别只在外层符号。

2.1 行内公式

  用单个 $ 包住。源码：

1
圆周率 $\pi$ 约等于 3.14159，而 $e^{i\pi} + 1 = 0$。

  渲染效果：圆周率 π\pi 约等于 3.14159，而 eiπ+1=0e^{i\pi} + 1 = 0。

  适合短公式、符号、变量。不要拿行内模式写长公式——它会把行高撑开，版面很难看。

2.2 独行公式

  用双 $$ 包住，公式会单独占一行并居中。源码：

1
$$\frac{a}{b} = \frac{c}{d}$$

  渲染效果：

ab=cd\frac{a}{b} = \frac{c}{d}

  适合重要的、需要看清楚推导过程的公式。这是写技术文章的主力。

2.3 一个小细节：行内样式与显示样式

  $$ 里的内容默认是“行内样式”，上下标和分数会挤在一起。想强制用“显示样式”（分数展开、上下标变大），在公式前面加 \displaystyle。对比：

写法渲染效果
$$\frac{a}{b}$$ab\frac{a}{b}
$$\displaystyle\frac{a}{b}$$ab\displaystyle\frac{a}{b}
$$\sum_{i=1}^n i$$∑i=1ni\sum_{i=1}^n i
$$\displaystyle\sum_{i=1}^n i$$∑i=1ni\displaystyle\sum_{i=1}^n i

  反过来，行内公式里想用显示样式也可以加 \displaystyle——但通常不建议，会让行高变得很高。

3 上下标

  这是最常用的一组：

语法渲染说明
x^2x2x^2上标用 ^
x_ixix_i下标用 _
x^{10}x10x^{10}多个字符必须加花括号
x_{ij}xijx_{ij}同上
x_i^2xi2x_i^2上下标可同时写
x_{i}^{2}xi2x_{i}^{2}也可以都加花括号
{}^{14}_{6}C614C{}^{14}_{6}C前置上下标（同位素）

  花括号这条一定要记住。 看对比：

你写的渲染结果对不对
x^10x10x^10★ 错，只有 1 是上标
x^{10}x10x^{10}✓
x_ijxijx_ij★ 错
x_{ij}xijx_{ij}✓
a^b^c报错★ 不能连续两个上标
a^{b^c}abca^{b^c}✓ 嵌套要加括号

  这是新手最常犯的错误，没有之一。

  另外，上下标可以嵌套任意层：x^{y^{z}} 渲染成 xyzx^{y^{z}}。

4 分数、根号、上下限

4.1 分数

  源码：

1
\frac{分子}{分母}

a+bc+d\frac{a+b}{c+d}

  嵌套也没问题：

语法渲染
\frac{1}{2}12\frac{1}{2}
\frac{1}{1+\frac{1}{x}}11+1x\frac{1}{1+\frac{1}{x}}
\dfrac{a}{b}ab\dfrac{a}{b}
\tfrac{a}{b}ab\tfrac{a}{b}

  \dfrac 强制用显示样式（大号），\tfrac 强制用小号。行内公式里的分数会缩得很小，要写清楚的分数就加 \dfrac 或改用独行公式。

4.2 根号

1
2
3
\sqrt{x}          % 平方根
\sqrt[3]{x}       % 三次根
\sqrt[n]{a}       % n 次根

xx3a2+b2n\sqrt{x} \qquad \sqrt[3]{x} \qquad \sqrt[n]{a^2+b^2}

4.3 求和、积分、极限

  用 _ 写下限、^ 写上标：

1
2
3
\sum_{i=1}^{n} i^2
\int_0^1 x^2 \, dx
\lim_{x \to 0} \frac{\sin x}{x}

∑i=1ni2∫01x2 dxlim⁡x→0sin⁡xx\sum_{i=1}^{n} i^2 \qquad \int_0^1 x^2 \, dx \qquad \lim_{x \to 0} \frac{\sin x}{x}

  几个细节：

  ——\qquad 是大空格，用来分隔并排的公式。\quad 小一点，\, 是很小的空隙（常在积分里 dx 前面加）。
  ——\to 是箭头 →\to，也可以用 \rightarrow。
  ——上下限写在哪取决于模式：独行公式里，\sum、\int、\lim 的上下限默认在符号的正上方/正下方；行内模式里会挪到右边。想强制在某处显示，用 \limits 和 \nolimits：

写法渲染
\sum_{i=1}^n（行内）∑i=1n\sum_{i=1}^n
\sum\limits_{i=1}^n（行内）∑i=1n\sum\limits_{i=1}^n

  多重积分：

语法渲染
\iint∬\iint
\iiint∭\iiint
\oint∮\oint
\int_a^b \int_c^d∫ab∫cd\int_a^b \int_c^d

  闭合积分和多重积分可以带上下限：\oint_C \vec{F}\cdot d\vec{r} → ∮CF⃗⋅dr⃗\oint_C \vec{F}\cdot d\vec{r}

5 多行公式

  一个推导写好几步，需要对齐，这时候用 aligned 环境。源码：

1
2
3
4
5
6
7
$$
\begin{aligned}
(a+b)^2 &= (a+b)(a+b) \\
        &= a^2 + ab + ba + b^2 \\
        &= a^2 + 2ab + b^2
\end{aligned}
$$

  渲染效果：

(a+b)2=(a+b)(a+b)=a2+ab+ba+b2=a2+2ab+b2\begin{aligned}(a+b)^2 &= (a+b)(a+b) \\ &= a^2 + ab + ba + b^2 \\ &= a^2 + 2ab + b^2\end{aligned}

  说明：

  ——\\ 是换行（两个反斜杠）。
  ——& 是对齐点。上面的写法让所有 = 对齐。想对齐别的位置就把 & 挪过去。
  ——aligned 必须写在 $$ 里面。这一点和完整的 LaTeX 不同。

  对齐点也可以有多个，比如要让等号和注释各成一列：

1
2
3
4
5
6
$$
\begin{aligned}
x &= 1 && \text{第一个根} \\
y &= 2 && \text{第二个根}
\end{aligned}
$$

x=1第一个根y=2第二个根\begin{aligned}x &= 1 && \text{第一个根} \\y &= 2 && \text{第二个根}\end{aligned}

  如果不想对齐，只是想换行，用 gathered：

1
2
3
4
5
6
$$
\begin{gathered}
x + y = 3 \\
x - y = 1
\end{gathered}
$$

x+y=3x−y=1\begin{gathered}x + y = 3 \\x - y = 1\end{gathered}

6 分段函数

  用 cases 环境。源码：

1
2
3
4
5
6
7
$$
|x| =
\begin{cases}
  x,  & x \geq 0 \\
  -x, & x < 0
\end{cases}
$$

∣x∣={x,x≥0−x,x<0|x| = \begin{cases} x, & x \geq 0 \\ -x, & x < 0 \end{cases}

  写法要点和 aligned 一样：& 分隔“内容”和“条件”，\\ 换行。逗号后面加 & 是为了让所有条件左对齐。

  带大括号的统一写法也很常见：

1
2
3
4
5
6
7
8
$$
f(x) =
\begin{cases}
  0,      & x < 0 \\
  x^2,    & 0 \leq x \leq 1 \\
  1,      & x > 1
\end{cases}
$$

f(x)={0,x<0x2,0≤x≤11,x>1f(x) = \begin{cases} 0, & x < 0 \\ x^2, & 0 \leq x \leq 1 \\ 1, & x > 1 \end{cases}

7 矩阵与向量

1
2
3
4
5
6
7
$$
A = \begin{pmatrix} a & b \\ c & d \end{pmatrix}
\qquad
B = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix}
\qquad
C = \begin{vmatrix} a & b \\ c & d \end{vmatrix}
$$

A=(abcd)B=[1001]C=∣abcd∣A = \begin{pmatrix} a & b \\ c & d \end{pmatrix}\qquadB = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix}\qquadC = \begin{vmatrix} a & b \\ c & d \end{vmatrix}

  各种括号对应的环境：

环境括号渲染
matrix无括号abcd\begin{matrix} a & b \\ c & d \end{matrix}
pmatrix圆括号 ( )(abcd)\begin{pmatrix} a & b \\ c & d \end{pmatrix}
bmatrix方括号 [ ][abcd]\begin{bmatrix} a & b \\ c & d \end{bmatrix}
Bmatrix花括号 { }{abcd}\begin{Bmatrix} a & b \\ c & d \end{Bmatrix}
vmatrix竖线 | |∣abcd∣\begin{vmatrix} a & b \\ c & d \end{vmatrix}
Vmatrix双竖线 ‖ ‖∥abcd∥\begin{Vmatrix} a & b \\ c & d \end{Vmatrix}

  & 分隔同一行的元素，\\ 分隔行。

  省略号：

语法渲染用途
\cdots⋯\cdots横向
\vdots⋮\vdots纵向
\ddots⋱\ddots斜向

  一个带省略号的矩阵：

1
2
3
4
5
6
7
8
$$
A = \begin{pmatrix}
  a_{11} & a_{12} & \cdots & a_{1n} \\
  a_{21} & a_{22} & \cdots & a_{2n} \\
  \vdots & \vdots & \ddots & \vdots \\
  a_{n1} & a_{n2} & \cdots & a_{nn}
\end{pmatrix}
$$

A=(a11a12⋯a1na21a22⋯a2n⋮⋮⋱⋮an1an2⋯ann)A = \begin{pmatrix} a_{11} & a_{12} & \cdots & a_{1n} \\ a_{21} & a_{22} & \cdots & a_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ a_{n1} & a_{n2} & \cdots & a_{nn}\end{pmatrix}

  行内的小矩阵用 \binom（组合数）或 \begin{smallmatrix}：

语法渲染
\binom{n}{k}(nk)\binom{n}{k}
\begin{smallmatrix} a & b \\ c & d \end{smallmatrix}abcd\begin{smallmatrix} a & b \\ c & d \end{smallmatrix}

8 自动调整大小的括号

  直接写 ( ) 的话，括号大小是固定的，包不住高一点的式子。对比：

写法渲染
(\frac{a}{b})(ab)(\frac{a}{b})
\left(\frac{a}{b}\right)(ab)\left(\frac{a}{b}\right)

  用 \left 和 \right 让括号自动适应内容高度：

语法渲染
\left( x \right)(x)\left( x \right)
\left[ x \right][x]\left[ x \right]
\left\{ x \right\}{x}\left\{ x \right\}
`\leftx \right
\left| x \right|∣x∣\left| x \right|
\left\langle x \right\rangle⟨x⟩\left\langle x \right\rangle
\left\lceil x \right\rceil⌈x⌉\left\lceil x \right\rceil
\left\lfloor x \right\rfloor⌊x⌋\left\lfloor x \right\rfloor

  注意：\left 和 \right 必须成对出现。如果只想让左边变大、右边不要括号，用 \right.（一个点表示“空的右括号”）：

1
\left. \frac{dy}{dx} \right|_{x=0}

dydx∣x=0\left. \frac{dy}{dx} \right|_{x=0}

  这是求导后代入某点的常见写法。

  还可以用 \big \Big \bigg \Bigg 手动指定大小（前面加 l/r 区分左右）：

语法渲染
\big( x \big)(x)\big( x \big)
\Big( x \Big)(x)\Big( x \Big)
\bigg( x \bigg)(x)\bigg( x \bigg)
\Bigg( x \Bigg)(x)\Bigg( x \Bigg)

9 排版细节

9.1 空格

  LaTeX 会忽略公式里你敲的空格。a b 和 ab 渲染出来一样。要加空格得用命令：

命令宽度渲染
\,很窄a ba\,b
\:稍宽a ba\:b
\;更宽a  ba\;b
\ （反斜杠+空格）一个空格a ba\ b
\quad一个字宽aba\quad b
\qquad两个字宽aba\qquad b
\!负空格（收紧）a ⁣ba\!b

9.2 公式里的文字

  公式里直接写中文或英文单词，会被当成变量，斜体且没有空格。对比：

写法渲染
x = speed \times timex=speed×timex = speed \times time
x = \text{speed} \times \text{time}x=speed×timex = \text{speed} \times \text{time}

  要用 \text{} 包住。公式里出现中文时尤其要注意——不包起来的话，字距会很难看：

写法渲染
\text{当} x > 0 \text{时}当x>0时\text{当} x > 0 \text{时}
当 x > 0 时（不包）当x>0时当 x > 0 时

9.3 公式编号

  想让公式带编号，用 \tag{}：

1
$$E = mc^2 \tag{1.1}$$

E=mc2(1.1)E = mc^2 \tag{1.1}

  技术文章里我习惯给重要公式编号，正文里就能写“由 (1.1) 式得”。

  编号内容和章节对应比较清楚，比如第 3 章第 2 个公式叫 \tag{3.2}。

9.4 颜色与框

  部分渲染器支持 \color 和 \boxed：

语法渲染
\boxed{E = mc^2}E=mc2\boxed{E = mc^2}
\color{red}{x}x\color{red}{x}

  \boxed 用来强调关键结论很有用。颜色的支持度不稳定，不同渲染器表现不一样，建议少用。

9.5 加粗与强调

语法渲染说明
\mathbf{x}x\mathbf{x}正体粗（向量、矩阵常用）
\boldsymbol{\alpha}α\boldsymbol{\alpha}粗体希腊字母
\mathit{x}x\mathit{x}斜体
\mathrm{d}d\mathrm{d}正体（如微分符号 d）
\mathbb{R}R\mathbb{R}空心（实数集）
\mathcal{L}L\mathcal{L}花体
\mathfrak{g}g\mathfrak{g}哥特体
\vec{a}a⃗\vec{a}箭头向量
\hat{x}x^\hat{x}帽子
\bar{x}xˉ\bar{x}上划线
\tilde{x}x~\tilde{x}波浪线
\dot{x}x˙\dot{x}一个点（对时间求导）
\ddot{x}x¨\ddot{x}两个点
\overline{AB}AB‾\overline{AB}长上划线
\underline{x}x‾\underline{x}下划线
\overrightarrow{AB}AB→\overrightarrow{AB}长箭头
\overbrace{x+y}^{n}x+y⏞n\overbrace{x+y}^{n}上花括号
\underbrace{x+y}_{n}x+y⏟n\underbrace{x+y}_{n}下花括号

  数学排版惯例：向量和矩阵用 \mathbf 或 \boldsymbol，集合用 \mathbb，算子用 \mathcal，微分符号 d 用 \mathrm{d}（正体，因为它是算子不是变量）。

10 符号速查表

  下面按类别列出常用符号的代码与渲染。可以用浏览器的“查找”在表里搜。

10.1 小写希腊字母

代码渲染代码渲染代码渲染代码渲染
\alphaα\alpha\betaβ\beta\gammaγ\gamma\deltaδ\delta
\epsilonϵ\epsilon\varepsilonε\varepsilon\zetaζ\zeta\etaη\eta
\thetaθ\theta\varthetaϑ\vartheta\iotaι\iota\kappaκ\kappa
\lambdaλ\lambda\muμ\mu\nuν\nu\xiξ\xi
\piπ\pi\varpiϖ\varpi\rhoρ\rho\varrhoϱ\varrho
\sigmaσ\sigma\varsigmaς\varsigma\tauτ\tau\upsilonυ\upsilon
\phiϕ\phi\varphiφ\varphi\chiχ\chi\psiψ\psi
\omegaω\omega

10.2 大写希腊字母

  注意：只有形状与拉丁字母不同的才有命令，像 Alpha、Beta 这些长得和 A、B 一样的直接写拉丁字母。

代码渲染代码渲染代码渲染代码渲染
\GammaΓ\Gamma\DeltaΔ\Delta\ThetaΘ\Theta\LambdaΛ\Lambda
\XiΞ\Xi\PiΠ\Pi\SigmaΣ\Sigma\UpsilonΥ\Upsilon
\PhiΦ\Phi\PsiΨ\Psi\OmegaΩ\Omega

10.3 二元运算符

代码渲染代码渲染代码渲染代码渲染
\pm±\pm\mp∓\mp\times×\times\div÷\div
\cdot⋅\cdot\ast∗\ast\star⋆\star\circ∘\circ
\bullet∙\bullet\oplus⊕\oplus\ominus⊖\ominus\otimes⊗\otimes
\odot⊙\odot\cup∪\cup\cap∩\cap\sqcup⊔\sqcup
\sqcap⊓\sqcap\vee∨\vee\wedge∧\wedge\setminus∖\setminus
\wr≀\wr\diamond⋄\diamond\triangleleft◃\triangleleft\triangleright▹\triangleright

10.4 关系符

代码渲染代码渲染代码渲染代码渲染
\leq≤\leq\geq≥\geq\neq≠\neq\approx≈\approx
\equiv≡\equiv\sim∼\sim\simeq≃\simeq\cong≅\cong
\propto∝\propto\ll≪\ll\gg≫\gg\asymp≍\asymp
\prec≺\prec\succ≻\succ\preceq⪯\preceq\succeq⪰\succeq
\subset⊂\subset\supset⊃\supset\subseteq⊆\subseteq\supseteq⊇\supseteq
\in∈\in\notin∉\notin\ni∋\ni\not\ni∌\not\ni
\perp⊥\perp\parallel∥\parallel\mid∣\mid\nmid∤\nmid
\doteq≐\doteq\models⊨\models\vdash⊢\vdash\dashv⊣\dashv
\lesssim≲\lesssim\gtrsim≳\gtrsim\lessgtr≶\lessgtr\gtrless≷\gtrless

10.5 箭头

代码渲染代码渲染代码渲染代码渲染
\to→\to\rightarrow→\rightarrow\leftarrow←\leftarrow\leftrightarrow↔\leftrightarrow
\Rightarrow⇒\Rightarrow\Leftarrow⇐\Leftarrow\Leftrightarrow⇔\Leftrightarrow\mapsto↦\mapsto
\uparrow↑\uparrow\downarrow↓\downarrow\updownarrow↕\updownarrow\Uparrow⇑\Uparrow
\nearrow↗\nearrow\searrow↘\searrow\swarrow↙\swarrow\nwarrow↖\nwarrow
\longrightarrow⟶\longrightarrow\longleftarrow⟵\longleftarrow\Longrightarrow⟹\Longrightarrow\Longleftrightarrow⟺\Longleftrightarrow
\hookrightarrow↪\hookrightarrow\hookleftarrow↩\hookleftarrow\rightharpoonup⇀\rightharpoonup\leftharpoonup↼\leftharpoonup

10.6 大运算符

代码渲染代码渲染代码渲染
\sum∑\sum\prod∏\prod\coprod∐\coprod
\int∫\int\iint∬\iint\iiint∭\iiint
\oint∮\oint\bigcup⋃\bigcup\bigcap⋂\bigcap
\bigoplus⨁\bigoplus\bigotimes⨂\bigotimes\bigodot⨀\bigodot
\bigvee⋁\bigvee\bigwedge⋀\bigwedge\biguplus⨄\biguplus
\bigsqcup⨆\bigsqcup

10.7 其它常用符号

代码渲染代码渲染代码渲染代码渲染
\infty∞\infty\partial∂\partial\nabla∇\nabla\forall∀\forall
\exists∃\exists\nexists∄\nexists\neg¬\neg\emptyset∅\emptyset
\varnothing∅\varnothing\angle∠\angle\triangle△\triangle\square□\square
\surd√\surd\top⊤\top\bot⊥\bot\alephℵ\aleph
\hbarℏ\hbar\ellℓ\ell\imathı\imath\jmathȷ\jmath
\Reℜ\Re\Imℑ\Im\wp℘\wp\prime′\prime
\degree°\degree\circ∘\circ\bullet∙\bullet\dots…\dots
\ldots…\ldots\cdots⋯\cdots\vdots⋮\vdots\ddots⋱\ddots
\clubsuit♣\clubsuit\diamondsuit♢\diamondsuit\heartsuit♡\heartsuit\spadesuit♠\spadesuit
\checkmark✓\checkmark\mho℧\mho\FinvℲ\Finv\Game⅁\Game

10.8 定界符

代码渲染代码渲染代码渲染
( )(( ))[ ][[ ]]\{ \}{\{ }\}
\langle \rangle⟨\langle ⟩\rangle\lceil \rceil⌈\lceil ⌉\rceil\lfloor \rfloor⌊\lfloor ⌋\rfloor
|∣|\backslash\\backslash\uparrow↑\uparrow
\Uparrow⇑\Uparrow\downarrow↓\downarrow\Downarrow⇓\Downarrow
\updownarrow↕\updownarrow\Updownarrow⇕\Updownarrow\vert∣\vert

10.9 函数名

  函数名一定要加反斜杠，否则会被当成变量相乘（斜体）：

代码渲染代码渲染代码渲染
\sinsin⁡\sin\coscos⁡\cos\tantan⁡\tan
\cotcot⁡\cot\secsec⁡\sec\csccsc⁡\csc
\arcsinarcsin⁡\arcsin\arccosarccos⁡\arccos\arctanarctan⁡\arctan
\sinhsinh⁡\sinh\coshcosh⁡\cosh\tanhtanh⁡\tanh
\loglog⁡\log\lnln⁡\ln\lglg⁡\lg
\expexp⁡\exp\degdeg⁡\deg\dimdim⁡\dim
\kerker⁡\ker\homhom⁡\hom\argarg⁡\arg
\maxmax⁡\max\minmin⁡\min\supsup⁡\sup
\infinf⁡\inf\limlim⁡\lim\limsuplim sup⁡\limsup
\liminflim inf⁡\liminf\gcdgcd⁡\gcd\detdet⁡\det
\bmod mod \bmod\pmod{n}(modn)\pmod{n}\PrPr⁡\Pr

  对比一下加与不加：

写法渲染
sin xsinxsin x
\sin xsin⁡x\sin x

10.10 声调与修饰符

代码渲染代码渲染代码渲染
\hat{a}a^\hat{a}\check{a}aˇ\check{a}\breve{a}a˘\breve{a}
\acute{a}aˊ\acute{a}\grave{a}aˋ\grave{a}\tilde{a}a~\tilde{a}
\bar{a}aˉ\bar{a}\vec{a}a⃗\vec{a}\dot{a}a˙\dot{a}
\ddot{a}a¨\ddot{a}\dddot{a}a...\dddot{a}\mathring{a}a˚\mathring{a}
\widehat{abc}abc^\widehat{abc}\widetilde{abc}abc~\widetilde{abc}\overline{abc}abc‾\overline{abc}
\underline{abc}abc‾\underline{abc}\overrightarrow{ab}ab→\overrightarrow{ab}\overleftarrow{ab}ab←\overleftarrow{ab}

10.11 括号与堆叠

代码渲染
\binom{n}{k}(nk)\binom{n}{k}
\dbinom{n}{k}(nk)\dbinom{n}{k}
\tbinom{n}{k}(nk)\tbinom{n}{k}
\overbrace{a+b}^{n}a+b⏞n\overbrace{a+b}^{n}
\underbrace{a+b}_{n}a+b⏟n\underbrace{a+b}_{n}
\stackrel{def}{=}=def\stackrel{def}{=}
\underset{x}{\max}max⁡x\underset{x}{\max}
\overset{x}{\max}max⁡x\overset{x}{\max}
{n \choose k}(nk){n \choose k}
{n \atop k}nk{n \atop k}
\substack{a \\ b}ab\substack{a \\ b}

10.12 间距与布局

代码说明渲染
\,细空格a ba\,b
\:中等空格a ba\:b
\;较宽空格a  ba\;b
\quad一个字宽aba\quad b
\qquad两个字宽aba\qquad b
\!负空格a ⁣ba\!b
\hspace{1cm}指定宽度aba\hspace{1cm}b
\phantom{x}占位但不可见axba\phantom{x}b
\hphantom{x}水平占位axxxba\hphantom{xxx}b
\vphantom{x}垂直占位—
\text{文字}正文文字文字\text{文字}
\textbf{文字}粗体文字文字\textbf{文字}
\mathit{文字}斜体文字文字\mathit{文字}

10.13 集合与逻辑

代码渲染代码渲染代码渲染
\mathbb{R}R\mathbb{R}\mathbb{N}N\mathbb{N}\mathbb{Z}Z\mathbb{Z}
\mathbb{Q}Q\mathbb{Q}\mathbb{C}C\mathbb{C}\mathbb{P}P\mathbb{P}
\mathcal{A}A\mathcal{A}\mathcal{B}B\mathcal{B}\mathcal{F}F\mathcal{F}
\mathfrak{A}A\mathfrak{A}\mathfrak{g}g\mathfrak{g}\mathfrak{h}h\mathfrak{h}
\varnothing∅\varnothing\emptyset∅\emptyset\complement∁\complement
\therefore∴\therefore\because∵\because\square□\square
\blacksquare■\blacksquare\triangle△\triangle\blacktriangle▲\blacktriangle

11 常见错误速查

症状原因解决
x^10 只有 1 是上标没加花括号写 x^{10}
公式整块不渲染，显示源码没开公式支持，或分隔符写错检查开关与 $ 配对
公式渲染成斜体一串函数名没加反斜杠写 \sin 而不是 sin
括号包不住分数用了固定大小括号改用 \left( \right)
分数太小看不清在行内公式里用 \dfrac 或改独行公式
中文和英文挤在一起没用 \text{}用 \text{中文} 包起来
一部分公式正常一部分是源码$ 数量不成对逐行数 $，确保成对
\left 报错没有配对的 \right补上 \right. 或 \right)
空格没生效LaTeX 忽略公式里的空格用 \quad、\, 等命令
换行没生效用了单个反斜杠用 \\（两个）
数学命令写在 HTML 标签里不生效HTML 块内不解析 Markdown把公式移到标签外，或改用文字

12 怎么查不会的符号

  最实用的方法：用 Detexify（http://detexify.kirelabs.org/classify.html）。在网页上画出符号的形状，它会告诉你对应的命令。手写识别，找不常见的符号特别快。

  其次是在线 LaTeX 编辑器（Overleaf 之类），边写边看效果。或者用支持实时预览的 Markdown 编辑器（VS Code 加插件、Typora、Obsidian 都行）。

  还有一招：看到别人的公式不会写，右键“查看页面源代码”，很多网站会把原始 LaTeX 放在 annotation 标签里（这是 KaTeX / MathJax 的标准做法，为了无障碍阅读）。这个页面的公式也能这么挖出来。

  另外推荐两个速查表：

资源地址
KaTeX 支持的命令https://katex.org/docs/supported.html
综合符号表https://en.wikibooks.org/wiki/LaTeX/Mathematics

13 最后

  LaTeX 的语法量比 Markdown 大不少，但常用的就那么几十个命令。上面这些覆盖了写技术内容 95% 的场景。

  真正要养成的习惯是三个：上下标加花括号、函数名加反斜杠、公式里的文字用 \text{} 包。这三个记住了，剩下的边用边查。

  至于公式排版得漂不漂亮，那是次要的。把推导讲清楚比把公式排好看重要得多。

  第 10 节那张符号表我尽量列全了，实际用的时候直接在页面里搜命令名就行。

]]> https://primerusse.top/2026/09/20/202609200500/ 2026-09-19T21:00:00.000Z 从上下标到矩阵推导，附完整的符号对照表。 LaTeX 入门 2026-09-19T21:00:00.000Z Primerusse 1 Markdown 是什么

  Markdown 是一种用纯文本写格式化文档的写法。

  传统做法是：写完文字，再用鼠标点一堆按钮设标题、加粗、插列表。Markdown 是另一种思路——你直接把这些格式“写”出来：

1
2
3
# 这是一级标题
**这是加粗**
- 这是列表项

  就这么简单。它有几个好处：

  ——纯文本。任何编辑器都能打开，不怕软件过时。
  ——手不离键盘。不用去点工具栏。
  ——通用。GitHub、知乎、语雀、Notion、Obsidian、Typora 全都支持。
  ——能转成别的格式。同一份文档可以输出成 HTML、PDF、Word。

  这篇教程的写法是：每讲一个语法，先给源码，紧接着把渲染效果摆出来。你对照着看，一眼就能明白两者的对应关系。

  半小时能学会常用语法，剩下的边用边查就行。

2 标题

  用 # 表示标题层级，几个 # 就是几级标题。源码：

1
2
3
4
5
6
# 一级标题
## 二级标题
### 三级标题
#### 四级标题
##### 五级标题
###### 六级标题

  渲染效果（受页面样式影响，这里只显示文字大小差异）：

一级标题

二级标题

三级标题

四级标题

五级标题
六级标题

  几个注意点：

  ——# 后面要有一个空格，#标题 不生效。
  ——一篇文章通常只用一个一级标题（一般就是文章标题）。正文的小节从二级开始。
  ——别为了“字大一点”乱用层级，标题层级会影响目录结构。
  ——最多六级，七级开始不生效。

  还有一种下划线式的写法，只能用于一二级标题：

1
2
3
4
5
一级标题
========

二级标题
--------

  这种写法现在很少用了，知道有这回事就行。

3 文字样式

  源码：

1
2
3
4
5
6
**粗体**
*斜体*
***粗斜体***
~~删除线~~
`行内代码`
普通文字

  渲染效果：

粗体　斜体　粗斜体　删除线　行内代码　普通文字

  也可以混着用，比如 粗体里有斜体、斜体里有粗体。

  用法上我自己的习惯：

  ——加粗用来强调关键结论、术语、需要一眼看到的东西。
  ——斜体用得少。中文里斜体效果不好看，而且容易和强调混淆；英文里斜体常用来表示书名、术语。
  ——行内代码用来标命令、文件名、变量名、路径。

  关于斜体还有个坑：* 和 _ 都能表示斜体，但 _ 在单词内部不生效（这是为了避免把 snake_case_name 这种变量名当成斜体）：

1
2
_snake_case_name_    会被渲染成斜体吗
my_file_name_here    下划线在词内，不生效

  渲染成：snake_case_name 和 my_file_name_here。所以涉及下划线的代码和变量名，一定用反引号包起来。

4 列表

4.1 无序列表

  源码：

1
2
3
- 苹果
- 香蕉
- 橘子

  渲染效果：

  • 苹果
  • 香蕉
  • 橘子

  也可以用 * 或 +，效果一样：

1
2
* 用星号
+ 用加号
  • 用星号
  • 用加号

  但同一篇里最好统一用 -，看着整齐。

4.2 有序列表

  源码：

1
2
3
1. 第一步
2. 第二步
3. 第三步

  渲染效果：

  1. 第一步
  2. 第二步
  3. 第三步

  有个反直觉的地方：你写的数字其实不重要。下面这样也能正确渲染：

1
2
3
1. 第一步
1. 第二步
1. 第三步
  1. 第一步
  2. 第二步
  3. 第三步

  Markdown 会自动编号。这个特性在插入新条目时很方便——不用手动改后面所有序号。

  但注意起始数字是有意义的：

1
2
5. 从五开始
6. 下一个
  1. 从五开始
  2. 下一个

4.3 嵌套列表

  子项前面加两个空格（或一个 Tab）。源码：

1
2
3
4
5
6
- 第一章
  - 第一节
  - 第二节
- 第二章
  1. 第一条
  2. 第二条

  渲染效果：

  • 第一章
    • 第一节
    • 第二节
  • 第二章
    1. 第一条
    2. 第二条

  缩进量要一致，一会两个空格一会四个空格，很容易渲染错。建议统一用两个空格。

4.4 任务列表

  源码：

1
2
3
- [x] 已经做完的事
- [ ] 还没做的事
- [ ] 另一件没做的事

  渲染效果：

  • [x] 已经做完的事
  • [ ] 还没做的事
  • [ ] 另一件没做的事

  注意 - 和 [ 之间有空格，[x] 里面是小写 x。

5 链接与图片

5.1 行内式链接

  源码：

1
[点我去百度](https://www.baidu.com)

  渲染效果：点我去百度

  还可以给链接加悬停提示：

1
[点我](https://www.baidu.com "这是鼠标悬停时的提示")

  渲染效果：点我（鼠标移上去看看）

5.2 引用式链接

  同一个链接在文中多次出现时，用引用式更清爽。源码：

1
2
3
这是[某个链接][1]，稍后还会提到[某个链接][1]。

[1]: https://www.baidu.com

  渲染效果：这是某个链接，稍后还会提到某个链接。

  好处是链接地址只在文末写一次，正文里很干净。

5.3 自动链接

  用尖括号包住 URL，会直接变成可点的链接：

1
2
<https://www.baidu.com>
<mailto:someone@example.com>

  渲染效果：https://www.baidu.com　mailto:someone@example.com

5.4 图片

  源码：

1
![图片说明](图片地址)

  开头的 ! 是关键，表示这是图片不是链接。方括号里的是替代文本（图片加载失败时显示，也用于无障碍阅读）。

  图片和链接一样，也支持悬停提示：

1
![说明](图片地址 "悬停提示")

  图片路径有两种写法：

  ——绝对路径 /assets/pictures/a.png：从网站根目录算起。换文章位置不用改路径，推荐。
  ——相对路径 ./a.png：从当前文件算起。

  在博客里我一般用绝对路径，因为文章可能在首页、归档页、标签页等多个位置显示，相对路径容易失效。

6 代码

6.1 行内代码

  源码：

1
安装完了敲 `npm install` 就能用。

  渲染效果：安装完了敲 npm install 就能用。

  行内代码里想包含反引号本身，用两个反引号包住：`有反引号的代码`。

6.2 代码块

  用三个反引号包住，后面写上语言名。源码：

1
2
3
4
```python
def hello():
    print("Hello")
```

  渲染效果：

1
2
def hello():
    print("Hello")

  写上语言名（python、javascript、bash、matlab……）才会有语法高亮。不写也能显示，但就是一片灰色：

1
2
3
没有语言名的代码块
def hello():
    print("Hello")

  几个容易忽略的点：

  ——代码块内不需要转义。想显示 # 就直接写 #，不会被当成标题。
  ——代码块里想包含三个反引号，外层就用四个或更多反引号包住（我上面那段示例就是这么写的）。
  ——缩进不要用 Tab。不同工具对 Tab 宽度处理不一样，用空格更保险（一般 2 或 4 个）。

7 引用块

  源码：

1
2
> 这是一段引用。
> 可以写多行。

  渲染效果：

这是一段引用。
可以写多行。

  引用可以嵌套：

1
2
3
4
5
6
> 第一层引用
>
> > 第二层引用
> > 还在第二层
>
> 回到第一层

第一层引用

第二层引用
还在第二层

回到第一层

  引用里也能放其他语法：

1
2
3
4
> **注意**：执行前请先备份。
>
> ```bash
> cp -r data data.bak
1
2
3
4
5

> **注意**：执行前请先备份。
>
> ```bash
> cp -r data data.bak

  引用常用于：摘录别人的话、强调注意事项、写“备注”。

8 表格

  源码：

1
2
3
4
| 名称 | 说明 | 价格 |
|:---|:---|:---:|
| 苹果 | 水果 | 5 元 |
| 螺丝刀 | 工具 | 12 元 |

  渲染效果：

名称说明价格
苹果水果5 元
螺丝刀工具12 元

  第二行那串 --- 是分隔行，必须写，它用来区分表头和内容。

  冒号控制对齐方式。源码：

1
2
3
4
| 左对齐 | 居中 | 右对齐 |
|:---|:---:|---:|
| 内容 | 内容 | 内容 |
| 长一点的内容 | 长一点的内容 | 长一点的内容 |
左对齐居中右对齐
内容内容内容
长一点的内容长一点的内容长一点的内容

  单元格里可以用其他语法：

1
2
3
4
5
| 格式 | 示例 |
|:---|:---|
| 粗体 | **加粗的文字** |
| 代码 | `npm install` |
| 链接 | [百度](https://www.baidu.com) |
格式示例
粗体加粗的文字
代码npm install
链接百度

  表格里不能用竖线——| 会被当成单元格分隔符。要打竖线得写成 \|：

1
2
3
| 符号 | 写法 |
|:---|:---|
| 竖线 | \| |
符号写法
竖线|

  表格的局限：不能有空行、不能跨行合并单元格、不能设置单元格背景色。要复杂表格得直接写 HTML。

9 分隔线

  单独一行写三个或更多的 -、*、_：

1
2
3
4
5
上面的内容

---

下面的内容

  渲染效果：

上面的内容

下面的内容

  注意：--- 在文件开头有特殊含义（表示 front-matter 的分隔符），别在该用的地方误用。

10 转义

  如果你想显示 Markdown 的符号本身，而不是让它生效，就在前面加反斜杠。源码：

1
2
3
\*这不是斜体\*
\# 这不是标题
\_这不是斜体\_

  渲染效果：

*这不是斜体*
# 这不是标题
_这不是斜体_

  常见需要转义的字符：

字符转义写法
\\\
`\`
*\*
_\_
{ }\{ \}
[ ]\[ \]
( )\( \)
#\#
+\+
-\-
.\.
!\!
||

11 段落与换行

  这是最容易出错的一块，单独讲。

11.1 段落：空一行

  源码：

1
2
3
4
这是第一段。
这行还属于第一段。

这是第二段。

  渲染效果：

这是第一段。
这行还属于第一段。

这是第二段。

  不空行的话，两行会被合并成一段。 这是新手最常遇到的困惑——明明在源码里换行了，渲染出来却连在一起。

11.2 强制换行：行尾两个空格

  如果确实想让同一段内的两行断开，在行尾加两个空格：

1
2
第一行（行尾有两个空格）  
第二行

  渲染效果：

第一行（行尾有两个空格）
第二行

  但这两个空格看不见，很容易被编辑器自动删掉（很多编辑器有“保存时删除行尾空格”的功能）。所以更稳的做法是空一行另起一段。

  也可以用 HTML 的 <br>：

1
第一行<br>第二行

第一行
第二行

11.3 缩进

  Markdown 默认不支持段落首行缩进。想缩进有两种办法：

  ——用全角空格 　（U+3000）；
  ——用 HTML 实体 &emsp;。

  这个博客用的是 &emsp;&emsp;（两个全角空格）来实现中文段落的缩进效果。

12 内联 HTML

  Markdown 允许直接写 HTML，这补上了它缺失的一些能力。源码：

1
2
3
4
5
这段文字<sup>上标</sup>和<sub>下标</sub>。

<center>这行会居中</center>

<kbd>Ctrl</kbd> + <kbd>C</kbd>

  渲染效果：

这段文字上标和下标。

这行会居中

Ctrl + C

  常见用途：

需求HTML 写法
上标<sup>文字</sup>
下标<sub>文字</sub>
居中<center>文字</center>
键盘按键<kbd>Ctrl</kbd>
强制换行<br>
折叠<details><summary>标题</summary>内容</details>

  但有个坑要注意：HTML 块内部的内容不按 Markdown 解析。比如：

1
<center>这里的 **加粗** 不会生效</center>

  渲染出来就是 <center>这里的 **加粗** 不会生效</center> ——星号原样显示。要加粗得直接写 <b>：

1
<center>这里的 <b>加粗</b> 会生效</center>
这里的 加粗 会生效

  这个特性还会影响别的：某些渲染器里，写在 HTML 标签内的数学公式 $...$ 也不会被处理。遇到公式不渲染时，先看看是不是被 HTML 标签包住了。

13 脚注

  源码：

1
2
3
这里有个说法需要注脚[^1]。

[^1]: 这是注脚的内容。

  渲染效果：

这里有个说法需要注脚[1]。

  脚注的支持度不如其他语法，有些平台不支持。写博客时用得不多，写学术类文档时比较有用。

14 几个实用建议

  ① 段落之间空一行。 前面说过，这是最常踩的坑。

  ② 中英文之间加空格。 习惯问题，但读起来舒服很多。比如写“使用 Python 脚本”而不是“使用Python脚本”。

  ③ 标点用中文全角。 中文内容里用 ，。：； 而不是 ,.:;。引号也要用全角的 “”，不要用英文的 ""——同一篇文章里混着用会很明显。

  ④ 文件名和路径用英文。 中文路径在有些工具链上会出编码问题。

  ⑤ 一个文件一个主题。 别把所有笔记堆在一个巨大的 md 里，以后找不到。

  ⑥ 标题层级不要跳。 从 ## 直接跳到 ####，目录结构会有问题。

  ⑦ 表格别太宽。 手机上看超过 4～5 列的表格会很难受。列多的信息考虑改成列表或分几张表。

15 用什么写

工具特点价格
VS Code免费，装 Markdown 插件就有实时预览。写代码的人顺手就用它免费
Typora所见即所得，写完直接是排版后的样子收费
Obsidian笔记软件，支持双向链接，适合建知识库免费
Logseq大纲式笔记，也支持双链免费
语雀 / Notion在线，能协作，导出 Markdown 也方便有免费版
纯文本编辑器记事本也行，就是没预览免费

  我个人日常用 VS Code 写技术文章，用 Obsidian 记零散笔记。工具不重要，选一个用顺手的一直用下去就行。

16 最后

  Markdown 的整个语法，一页纸就能印完。它不是一门需要“学”的语言，而是一种写字的习惯。

  真正要注意的不是语法，而是内容组织：标题层级合不合理、列表有没有嵌套太深、表格有没有必要、一段话是不是太长。这些跟用什么标记语言没关系。

  语法忘了随时查，网上速查表一大把。先用起来。

  1. 这是注脚的内容。 ↩︎

]]> https://primerusse.top/2026/09/20/202609200400/ 2026-09-19T20:00:00.000Z 每一个语法都附渲染效果，跟着看一遍就会。 Markdown 入门 2026-09-19T20:00:00.000Z Primerusse 1 静态博客是怎么回事

  博客分两种：动态和静态。

  动态博客（WordPress、Typecho 这类）需要一台服务器，每次有人访问，服务器现场查数据库、拼页面、再发给你。功能强，但要维护服务器、要操心数据库、访问量一大就慢。

  静态博客（Hexo、Hugo、Jekyll 这类）是在你自己电脑上把文章提前编译成 HTML，然后把这一堆 HTML 文件扔到任何能托管文件的地方。访客拿到的就是现成的页面，没有数据库、没有后端。

  静态博客的好处很实在：

  ——快。没有数据库查询，纯静态文件，秒开。
  ——省。托管到 GitHub Pages、Cloudflare Pages 都免费；自己有服务器的话资源占用也极低。
  ——安全。没有后端，也就没有后端漏洞可打。
  ——文章是自己的。全部是本地 Markdown 文件，随时能搬走。

  代价是：评论、搜索这些“动态”功能得另外想办法（用第三方服务，或者干脆不要）。对我来说这笔交易很划算——我只是想安静地写东西。

  这个博客就是用 Hexo 搭的，主题是 Stellar，部署在自己的服务器上。下面是我实际走了一遍的流程。

2 装环境

  需要两样东西：Node.js 和 Git。

  Node.js：去官网 https://nodejs.org/ 下 LTS 版本（长期支持版），一路下一步就行。装完在终端里敲 node -v，能输出版本号就成了。

  Git：从 https://git-scm.com/ 下载安装。装完敲 git --version 验证。

  两个都装好后，装 Hexo 的命令行工具：

1
npm install -g hexo-cli

  如果这一步报网络错误，多半是 npm 源的问题，换成国内镜像：

1
npm config set registry https://registry.npmmirror.com

3 建站与目录结构

  找个放博客的目录，执行：

1
2
3
hexo init my-blog
cd my-blog
npm install

  hexo init 会生成一套完整的目录骨架。装完依赖后，本地预览：

1
hexo server

  浏览器打开 http://localhost:4000，能看到默认页面就成了。

3.1 目录结构

  Hexo 的目录结构不复杂，但几个关键目录要分清：

1
2
3
4
5
6
7
8
9
10
my-blog/
├── _config.yml          站点配置（标题、作者、部署方式）
├── package.json         依赖清单
├── scaffolds/           新建文章的模板
├── source/              你写的东西都在这里
│   ├── _posts/          文章（Markdown）
│   ├── _data/           数据文件（分类、标签等）
│   └── about/           独立页面
├── themes/              主题
└── public/              编译产物（自动生成，不用管）

  核心就一句话：source/_posts/ 里放 Markdown，_config.yml 里改配置，themes/ 里换主题。 其它都是自动的。

  public/ 是编译产物，不要手动改——下次 hexo generate 会覆盖掉。要改样式改主题文件或配置，不要动编译结果。

3.2 常用命令

命令作用
hexo new "标题"新建文章
hexo new page "关于"新建独立页面
hexo server本地预览（默认 4000 端口）
hexo generate编译成静态文件
hexo clean删掉编译产物和缓存
hexo deploy部署
hexo clean && hexo generate改配置后必做

  提醒一下：改了配置文件、主题、或者 front-matter，都要 hexo clean 再 hexo generate，否则可能读的是缓存。

4 写第一篇文章

1
hexo new "我的第一篇文章"

  这会在 source/_posts/ 里生成一个 .md 文件，开头是文章元信息（front-matter）：

1
2
3
4
5
---
title: 我的第一篇文章
date: 2026-09-20 10:00:00
tags: [随笔]
---

  下面的正文用 Markdown 写。不熟悉 Markdown 的话见Markdown 入门。

  几个常用的 front-matter 字段：

字段作用
title文章标题
date发布日期（决定排序）
tags标签，写成 YAML 数组 [a, b]
categories分类
description摘要，首页卡片和搜索结果会用到
cover封面图路径
banner文章页顶部大图
katex是否加载数学公式支持

  建议每篇都写 description。 首页卡片如果没摘要会取正文前几十个字，效果通常很难看。

  还有个细节：文件名决定 URL。Hexo 默认按 日期/标题 生成路径，如果你手动改了文件名，URL 也会跟着变，已经发出去的链接会失效。想固定 URL 的话，最稳妥的做法是一开始就用“日期+序号”这种不含中文的名字，比如 202609200100.md。

5 主题：我用的是 Stellar

  Hexo 自带一个很朴素的主题。我试过几个之后选了 Stellar。

5.1 主题信息

项目内容
名称Stellar
作者xaoxuu
仓库https://github.com/xaoxuu/hexo-theme-stellar
文档https://xaoxuu.com/wiki/stellar/
版本我用的 1.44.0
许可开源

  选它的原因有几个：

  ——自带的功能够全。标签页、归档、搜索、相关文章、目录、代码高亮、数学公式，开箱就有，不用自己一个个装插件。
  ——Wiki 系统。这是它比较特别的地方：可以把文章组织成项目式的“书架”，适合写系列文章。这个博客的数学、Abaqus、MATLAB 几个专栏就是用这套东西组织的。
  ——配置文件分开放。主题自己的配置在 _config.stellar.yml，和站点的 _config.yml 分开，升级主题时不会被覆盖。
  ——可定制程度高。想改样式可以直接注入自定义 CSS，不用去改主题源码。

5.2 安装

  两种方式，选一种：

1
2
3
4
5
# 方式一：Git 克隆（推荐，方便升级和改源码）
git clone https://github.com/xaoxuu/hexo-theme-stellar themes/stellar

# 方式二：npm 安装（简单，但不方便改源码）
npm install hexo-theme-stellar --save

  然后在 _config.yml 里指定：

1
theme: stellar

  建议用 Git 克隆的方式。 因为主题文档里推荐的很多效果（自定义样式、局部改版）需要能看到主题源码；npm 装的话文件在 node_modules 里，改起来不方便。

5.3 配置

  Stellar 的配置分两个文件：

文件作用
_config.yml（站点根目录）站点信息：标题、作者、部署方式、theme
_config.stellar.yml（站点根目录）主题配置：菜单、侧栏、样式、插件

  主题自己的默认配置在 themes/stellar/_config.yml，不要直接改它。 正确做法是在站点根目录建一个 _config.stellar.yml，把要改的项写进去——同名文件会覆盖主题默认值。这样升级主题时你的配置不会丢。

  常改的几项：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 站点标题与副标题
logo:
  title: 你的博客名
  subtitle: 副标题

# 顶部导航
menubar:
  columns: 4
  items:
    - id: post
      name: 博客
      path: /
    - id: wiki
      name: 项目
      path: /wiki/

# 左侧栏样式
style:
  leftbar: glass

  主题还支持注入自定义内容（inject.head），这是自定义样式的入口。我的做法是把所有自定义 CSS 写成一个 <style> 块塞在里面——好处是升级主题不会丢，坏处是这个文件会越来越长。

5.4 我改动的部分

  主题再好也有不合适的地方，我改了几处。这里记一下，因为升级主题时这些改动会被覆盖：

文件改了什么不改的后果
layout/_partial/main/article/related_posts.ejs兼容 wiki 页面的标签格式 + 去重wiki 页面整页报错
layout/page.ejs让 wiki 页面也显示相关文章wiki 页没有相关文章
layout/tags.ejs一级标签优先排序标签页顺序混乱
layout/_partial/head.ejs微信 X5 浏览器的 viewport 适配微信里字号偏小

  教训是：改主题源码一定要记下来。 我第一次升级主题时忘了这回事，几个功能直接坏了，排查了半天。现在我在项目根目录放了一份改动清单，升级前先看一遍。

  还有一点值得说：主题的配置项和主题的源码是两回事。配置项（_config.stellar.yml）升级不会丢，源码改动会丢。所以能用配置解决的，别去改源码。

6 部署：我用的是自己的服务器

  编译一次看看：

1
2
hexo clean      # 清掉旧的编译产物
hexo generate   # 重新编译，产物在 public/

  public/ 里就是完整的静态站点。把它放到任何能托管静态文件的地方就行。下面三种方案我都了解过，我最终选的是方案 B。

6.1 方案 A：GitHub Pages（免费，最省事）

  （1）在 GitHub 建一个仓库，名字必须是 <你的用户名>.github.io。

  （2）装部署插件：

1
npm install hexo-deployer-git --save

  （3）改 _config.yml：

1
2
3
4
deploy:
  type: git
  repo: https://github.com/<用户名>/<用户名>.github.io.git
  branch: main

  （4）部署：

1
hexo deploy

  等一两分钟，访问 https://<用户名>.github.io 就能看到了。

  缺点：国内访问 GitHub Pages 时快时慢；想绑自己的域名要额外配置；不能跑任何服务端逻辑。

6.2 方案 B：自己的服务器（我用的这个）

  有服务器和域名的话，可以自己搭。思路是：服务器上放一个 Git 裸仓库，本地推送，服务器收到后自动把文件同步到网站目录。

  这套流程的好处是完全自主——域名、HTTPS、缓存策略都由你定，访问速度也比 GitHub Pages 稳定。代价是要自己维护服务器。

  我的环境是 Ubuntu + Nginx，下面是完整步骤。

服务器端准备

  （1）装 Nginx 和 Git：

1
apt update && apt install -y nginx git

  （2）建两个目录——一个放裸仓库，一个放网站文件：

1
2
3
mkdir -p /var/repo/blog.git
mkdir -p /var/www/blog
cd /var/repo/blog.git && git init --bare

  （3）关键一步：在裸仓库里加一个 hooks/post-receive 钩子，让 Git 收到推送后自动把内容同步到网站目录：

1
2
#!/bin/sh
GIT_WORK_TREE=/var/www/blog git --git-dir=/var/repo/blog.git reset --hard master

  给它执行权限：

1
chmod +x /var/repo/blog.git/hooks/post-receive

  这行命令的意思是：把 master 分支的内容强制检出到 /var/www/blog。每次推送，网站目录就自动更新了，不需要你手动上传文件。

  （4）配置 Nginx，把站点根目录指向 /var/www/blog：

1
2
3
4
5
6
7
8
9
10
server {
    listen 80;
    server_name your-domain.com;
    root /var/www/blog;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

  （5）重载 Nginx：

1
nginx -t && systemctl reload nginx

本地配置

  改 _config.yml 的部署设置：

1
2
3
4
deploy:
  type: git
  repo: root@<服务器IP>:/var/repo/blog.git
  branch: master

  然后 hexo deploy 就会推送到服务器。

免密推送

  每次部署都输密码很烦，配一下 SSH 免密：

1
2
3
4
5
# 本地生成密钥（已有的话跳过）
ssh-keygen -t ed25519

# 把公钥传到服务器
ssh-copy-id root@<服务器IP>

  之后 hexo deploy 就不用输密码了。

HTTPS

  用 Certbot 申请免费证书最省事：

1
2
apt install -y certbot python3-certbot-nginx
certbot --nginx -d your-domain.com

  它会自动改 Nginx 配置并设置证书自动续期。

6.3 方案 C：Cloudflare Pages / Vercel（免费，自动构建）

  把博客源码推到 GitHub，然后在 Cloudflare Pages 里连上这个仓库，每次推送它自动编译部署。适合不想在自己电脑上存编译产物的人。

  缺点：构建过程你看不到细节，出问题不好排查；国内访问速度一般。

6.4 三种方案怎么选

GitHub Pages自己的服务器Cloudflare Pages
费用免费服务器+域名费用免费
国内速度一般取决于服务器线路一般
自定义程度低完全自主中
维护成本几乎为零要自己维护极低
绑定域名要额外配置直接配支持
适合谁只想写文章想完全掌控不想碰服务器

  我的选择是方案 B，主要图两点：一是访问速度可控（服务器线路自己挑），二是这套流程本身有学习价值——配下来会顺带搞明白 Git hook、Nginx、SSH、HTTPS 是怎么回事。

7 部署脚本

  每次都要敲三四条命令挺烦的，写个脚本一次搞定。Windows 下用批处理：

1
2
3
4
5
6
@echo off
cd /d "%~dp0"
call hexo clean
call hexo generate
call hexo deploy
pause

  存成 deploy.bat，以后双击就行。

  不过光看部署命令不报错，不代表真的推上去了。SSH 偶发超时、远端仓库有问题，都可能让部署静默失败。所以更稳妥的做法是在部署后加一步验证：

1
2
3
4
5
6
7
8
@echo off
cd /d "%~dp0"
call hexo clean
call hexo generate
call hexo deploy
REM 验证线上是否真的更新了
curl -s -o nul -w "%%{http_code}\n" https://your-domain.com/
pause

  返回 200 才算成功。这个博客的部署脚本就是按这个思路写的，还会顺带检查站内失效链接。

8 进阶：几个值得做的事

  ① 站内搜索。 Hexo 有 hexo-generator-searchdb 之类的插件，生成一个 JSON 索引，前端搜索。Stellar 主题内置了支持。

  ② 图片优化。 原始截图动辄几 MB，直接放上去会让页面很慢。建议统一压成 WebP，长边控制在 1920 以内。我写了个脚本批量处理——这一步对加载速度的影响比任何前端优化都大。

  ③ 失效链接检查。 文章一多，改了文件名、删了图片，就会出现死链。写个脚本在部署前扫一遍 HTML 里的站内链接，能避免上线后才发现。

  ④ 备份。 博客源码要备份。最省事的做法是把整个目录（除了 node_modules 和 public）放进一个 Git 仓库，推到私有仓库里。

  ⑤ 统计。 想知道哪些文章有人看，可以接 Google Analytics、Umami、或者自建统计。不喜欢被追踪的话，用 Nginx 日志自己分析也行。

9 几个踩过的坑

  ① 改了配置不生效。 Hexo 会缓存编译结果，改完配置先 hexo clean 再 hexo generate。

  ② 图片不显示。 检查路径写法。放在 source/assets/ 下的图片，引用路径是 /assets/...（对应网站根目录），不要写成相对路径。文章可能在首页、归档页、标签页等多个位置渲染，相对路径很容易失效。

  ③ 部署成功但网站没变。 先按 Ctrl+Shift+R 强制刷新（可能是浏览器缓存）；还没变就检查是不是推到了别的分支；再不行就登服务器看 /var/www/blog 里文件的时间戳。

  ④ 主题升级后功能坏了。 如果你改过主题源码，升级会全部覆盖。记住自己改了哪些文件——这是我踩过最深的坑。

  ⑤ 中文文件名或路径报错。 尽量全部用英文命名目录和脚本文件。有些工具链对中文路径的编码处理不可靠。尤其是 .bat 文件——cmd 按代码页解析批处理，里面的中文注释会被切分误读，导致莫名其妙的语法错误。

  ⑥ 部署时 SSH 偶发失败。 Could not read from remote repository 这类错误，多半是网络抖动。在脚本里加自动重试（等 30 秒重试，最多试三次）能省很多心。

  ⑦ 服务器磁盘被日志撑满。 Nginx 的 access log 长期不清理能涨到几个 GB。配一下 logrotate，或者定期清理。

10 值不值得

  如果你只想写文章、不想碰技术，用现成的平台（知乎、语雀、Notion）效率更高。

  但如果你想完全掌控自己的内容——排版、域名、数据、以后能不能导出——那静态博客是很好的选择。搭一次花一个周末，之后就是纯粹的写作。

  而且这个过程本身有收获：你会顺带搞明白 Git、命令行、Nginx、DNS、HTTPS 这些东西是怎么回事。这些东西学一次，以后到处都用得上。

]]> https://primerusse.top/2026/09/20/202609200300/ 2026-09-19T19:00:00.000Z 从零建站、换主题、部署到自己的服务器。 用 Hexo 搭一个静态博客 2026-09-19T19:00:00.000Z Primerusse 1 为什么要自己搭 NAS

  用网盘不挺好吗？对我来说有三个绕不过去的理由：

  一是容量和成本。网盘会员一年一两百，容量还有上限；自己一块 4TB 硬盘能用到硬盘坏。

  二是数据是自己的。网盘限速、删文件、改规则，你都只能接受。自己搭的，硬盘在你手上。

  三是能跑别的东西。NAS 不只是存文件——同步、备份、下载、看片、跑个小服务，都是顺手的事。

  fnOS（飞牛私有云）是近几年比较省心的选择：基于 Debian，界面做得像成品 NAS，但底层是完整的 Linux，想折腾随时能进命令行。

2 硬件：我走的 DIY 路线

  做 NAS 的硬件有三条路线，我三条都试过或帮人装过，最后自己 DIY 了一台。

2.1 三条路线对比

路线说明优点缺点
旧电脑改造淘汰的台式机装 fnOS零成本试水费电、体积大、盘位少
成品小主机N100 迷你主机 + 外置硬盘柜省心、功耗低盘位固定、扩展性差、硬盘柜额外花钱
DIY 机箱ITX 主板 + NAS 专用机箱盘位多、可扩展、功耗可控要自己装机、选型费心、成本最高

  我最后选的是第三条：自己 DIY 一台。

  原因很实际：前两条路我都试过，都不满意。旧电脑改造噪音大、功耗高，放在卧室根本没法睡；成品小主机加硬盘柜看着省事，但硬盘柜的供电和散热都是短板，而且硬盘柜走 USB，长时间高负载下容易掉盘——这个风险我不想承担。

  DIY 一台的好处是每个环节都自己可控：盘位想加就加、风扇想换就换、硬盘的散热和供电能认真做。代价是要花时间选型和装机。

2.2 DIY 的选型思路

  DIY NAS 和 DIY 普通台式机不一样，顺序应该反过来：普通装机先定 CPU，NAS 装机先定机箱。

  因为机箱决定了你能装几块盘、盘怎么散热、主板能有多大，这三件事又反过来限制了主板和电源的选择。先买 CPU 再找机箱，很容易发现装不下。

  我的选型顺序是：机箱 → 主板 → CPU → 电源 → 硬盘。

机箱

  NAS 机箱的核心指标是盘位数量和硬盘散热方式。常见的有几类：

类型盘位特点
小型 ITX 机箱2～4体积小，但盘多了散热紧张
NAS 专用机箱（如乔思伯 N 系列）4～8硬盘有独立风道，推荐
塔式机箱改造6～10+便宜、扩展性好，但体积大
服务器机箱12+专业，但噪音大、功耗高

  选的时候注意几点：

  ——硬盘要有独立风道。硬盘最怕热，一堆硬盘挤在一起没风道，夏天能到 50℃ 以上，寿命会明显缩短。好的 NAS 机箱会在硬盘笼前面留一排风扇位。
  ——硬盘架要好装。以后换盘、加盘是常事，能免工具抽拉的最好。
  ——注意主板尺寸限制。ITX 机箱只能装 ITX 主板，选之前确认清楚。
  ——电源尺寸。很多小机箱只能装 SFX 电源，不是标准 ATX。

主板

  NAS 主板最关键的是SATA 接口数量——它直接决定你能接几块硬盘。

  普通 ITX 主板一般只有 2～4 个 SATA 口，不够用。解决办法有三种：

  ——选 SATA 口多的主板。有些 NAS 专用主板能提供 6 个。
  ——加 PCIe 转 SATA 扩展卡。便宜，但要注意芯片型号（推荐 ASM1166、JMB585 这类，别买杂牌的）。
  ——加 HBA 卡。专业方案，能接 8 块以上，但要考虑散热和功耗。

  另外两个点：网口最好带 2.5G（现在很常见，配合 2.5G 交换机能跑满机械硬盘速度）；M.2 插槽用来装系统盘，能让机械盘全部留给数据。

CPU

  NAS 对 CPU 性能要求很低，重点是功耗和核显。

  Intel 的 N100 / N305 这类低功耗芯片是当前首选：整机待机功耗能压到 10～20W，还带核显（Jellyfin 硬解需要它）。AMD 的话 Ryzen 嵌入式系列也可以，但核显支持不如 Intel 成熟。

  不要上高性能 CPU。 NAS 是 24 小时开机的设备，一颗 65W 的 CPU 一年电费比硬盘还贵，而且散热和噪音都难处理。

电源

  电源是被最多人忽略的一环，但对 NAS 来说极其重要——硬盘最怕的就是供电不稳和突然断电，这是直接导致硬盘损坏的主要原因之一。

  三个要点：

  ——选质量好的品牌电源，不要用杂牌。NAS 长期运行，电源是整机寿命的短板。
  ——功率要留余量。机械硬盘启动瞬间电流很大（每块盘启动峰值约 2A@12V），4 块盘同时启动的冲击不小。一般 4 盘位配 300W 以上比较稳妥。
  ——有条件上 UPS。市电波动、跳闸对 NAS 是致命的。一台小的后备式 UPS 能让你在不来电时安全关机，这笔钱花得值。

硬盘

  这是最该花钱的地方。两件事要说清楚。

  第一，别买叠瓦盘（SMR）。 叠瓦盘的磁道是重叠写的，改写数据时要重写整条磁道，写入性能极差，而且组 RAID 时容易出现掉盘和重建失败。买之前查一下型号是不是垂直盘（CMR）——这个信息通常能在厂商的规格表或第三方数据库里查到。

  第二，别买同批次同型号的盘。 同一批次生产的盘，工艺和寿命曲线接近，很可能会在同一时间集中出故障——这对 RAID 是灾难性的。建议分批买，或者至少混用不同品牌/系列。

  NAS 专用盘（如 WD Red Plus、Seagate IronWolf）和普通桌面盘的区别主要在固件：NAS 盘针对 7×24 运行、多盘振动环境做了优化，且通常明确支持 RAID（桌面盘在 RAID 下可能因超时设置问题被判定为掉盘）。

2.3 装机的几个注意点

  装机的过程和普通台式机差不多，但有几点是 NAS 特有的：

  ——硬盘固定要牢。振动是硬盘的敌人，尤其是多盘位机箱。硬盘螺丝一定要上齐，有的机箱还配减震垫，别省。
  ——风道要顺。一般是前面进风（吹过硬盘）、后面和上面出风。风扇不用追求大风量，要的是持续的低速气流——高转速风扇的噪音在安静的房间里很难忍。
  ——走线要整洁。不是为了好看，而是线材挡住风道会明显影响硬盘温度。
  ——先别装硬盘盖，开机测温度。装完系统跑一段时间，看看硬盘温度是否在 40℃ 以下。偏高的话加风扇或调整风道。
  ——系统盘和数据盘分开。系统装在 M.2 或一块小 SSD 上，别和数据盘混用，这样以后重装系统不影响数据。

  DIY 一台的成本大概是这样（按 4 盘位算，不含硬盘）：

部件大致价位
NAS 机箱300～800
ITX 主板 + N100/N305600～1200
内存 8～16GB150～400
电源（SFX/ATX）200～500
系统 SSD（128GB）100～200
风扇、线材等100～200
合计约 1500～3300

  硬盘另算。和成品 NAS（同盘位通常 2000 以上且不含硬盘）比，DIY 的价格优势不算大，真正的好处是可扩展和可维修——哪块坏了换哪块，想加盘位加盘位。

3 装 fnOS

3.1 做启动盘

  和装系统一样，用 Rufus 或 Ventoy 把 fnOS 的 ISO 写进 U 盘。具体步骤见如何重装系统：Rufus 与 Ventoy 怎么选。

  fnOS 的 ISO 从官网 https://www.fnnas.com/ 下载。

3.2 安装

  （1）目标机器插上启动盘，开机进 BIOS 选 U 盘启动。

  （2）fnOS 安装向导会问装到哪块盘。选那块小 SSD 或 M.2，不要选数据盘。

  （3）设置管理员账号和密码，记好——这是之后登录网页后台的凭据。

  （4）等安装完成，重启，拔掉 U 盘。

  （5）在浏览器里访问 http://<NAS的IP>:8000，进入后台。IP 可以在路由器后台的设备列表里找，也可以在 fnOS 的终端里用 ip a 看。

  建议在路由器里给 NAS 分配一个固定的内网 IP（DHCP 静态绑定），否则路由器重启后 IP 可能变，你就找不到它了。

4 配存储

  这是 NAS 的核心，也是最容易踩坑的地方。

4.1 先想清楚要不要组 RAID

  RAID 不是备份。这句话要记住。RAID 解决的是硬盘坏了服务不停，不解决误删、中勒索病毒、整机烧了。

方案空间利用率能坏几块盘说明
单盘（Basic）100%0简单，但盘坏了数据就没了
RAID 150%1两块盘互为镜像，最稳当
RAID 5(n−1)/n1三块起，性价比平衡
RAID 6(n−2)/n2四块起，更安全
RAID 1050%每对 1 块四块起，性能最好，利用率最低

  我的建议：两块盘就用 RAID 1；三块以上用 RAID 5；重要数据另外再备份一份到别的地方（另一台机器、云盘、移动硬盘都行）。

  特别提醒：RAID 5 在大容量机械盘上重建时间很长（几 TB 可能十几个小时），重建期间再坏一块就全没了。盘越大风险越高。所以四块盘以上，RAID 6 更稳妥。

  还有个容易混淆的概念：RAID 不是备份，快照也不是备份。快照能救误删，但救不了硬盘物理损坏（如果快照和数据在同一组盘上）。真正的备份必须在另一台设备上。

4.2 建立存储池

  （1）进“存储”→“创建存储池”。

  （2）选 RAID 类型，勾选要加入的硬盘。加入的盘会被清空，先确认里面没有数据。

  （3）格式化文件系统。fnOS 支持 ext4 和 btrfs——btrfs 支持快照，想做定期快照就选它；只求稳就 ext4。

  （4）创建完成后，会得到一个存储空间。可以再在里面建共享文件夹。

  btrfs 和 ext4 怎么选：需要快照、需要校验数据完整性（能发现静默损坏）就选 btrfs；追求最简单的稳定性和兼容性选 ext4。我自己的数据盘用的 btrfs，主要就是用它的快照。

4.3 建共享文件夹

  按用途分，别全堆在一个目录：

1
2
3
4
5
6
/vol1/
├── documents/     文档
├── photos/        照片
├── media/         影音
├── backup/        备份
└── docker/        容器数据

  分开放的好处是：以后要做快照、限速、单独备份，都能按目录来。

  另外建议给每个用途单独设权限。比如 photos 只给家人读、backup 只有管理员能写——少一个入口就少一分风险。

5 用起来

5.1 电脑访问（SMB）

  Windows 里直接开“文件资源管理器”，地址栏输入 \\<NAS的IP>，回车就能看到共享文件夹。可以右键映射成网络驱动器，之后就当本地盘用。

  macOS 在“访达”里按 ⌘K，输入 smb://<NAS的IP>。

  如果连不上，检查三件事：fnOS 里的 SMB 服务开了没；用户名密码对不对；老版 Windows 可能因为 SMB 协议版本报错，在 fnOS 侧把最低协议版本调低即可。Windows 11 家庭版还有一个坑：默认禁用“不安全的来宾登录”，需要在组策略或注册表里放开。

5.2 手机访问

  fnOS 有自己的手机 App，装上扫码或输地址登录，能看图、看片、传文件。也可以直接用支持 SMB 的第三方文件管理器。

  手机上访问 NAS 的体验，取决于你家的 Wi-Fi。5GHz 频段 + 千兆以上的内网，看 4K 原盘都够；如果走 2.4GHz，大文件传输会很慢。

5.3 远程访问

  在家里局域网用当然没问题，但在外面怎么访问？三种思路：

  ① 官方内网穿透：fnOS 自带远程访问功能，配置最简单，走官方服务器中转。免费版有速率限制。

  ② 自己搭隧道：用 frp、Cloudflare Tunnel 之类。免费、不限速，但要自己配，且需要一台有公网 IP 的服务器。

  ③ 端口映射：如果家里宽带有公网 IP，直接在路由器上把端口映射出去。但这样等于把 NAS 暴露在公网上，安全性靠自己保证——一定要改默认端口、用强密码、开防火墙，最好再加一层 VPN。

  我自己用的是方案 ②，Cloudflare Tunnel。不开放任何端口，用起来也省心。

5.4 Docker

  fnOS 支持 Docker，这是它相对成品 NAS 最大的优势。常见的玩法：

服务用途
qBittorrent / Transmission下载
Jellyfin / Emby影音库与转码
Immich / PhotoPrism照片管理（替代 iCloud / Google Photos）
Vaultwarden密码管理（替代 1Password）
Alist挂载各家网盘成统一目录
Home Assistant智能家居
AdGuard Home全网去广告（把 DNS 指向它）
Syncthing多设备文件同步

  装法就是在“Docker”里搜镜像、配端口和挂载目录。刚开始建议一个一个来，别一次装一堆——出问题不知道是哪个。

  两个建议：

  ——容器数据要挂到存储池里，不要留在系统盘。否则重装系统时容器配置全丢。
  ——把端口和挂载路径记下来。写在文档里或者笔记里，将来迁移时能省大量时间。

6 几个必要的习惯

  ① 定期快照。 btrfs 支持快照，设个每天自动拍摄。误删文件时能救回来。

  ② 异地备份。 本地 RAID 挡不住火灾、盗窃、雷击。重要数据至少再放一份在别的地方。业界有个说法叫“3-2-1 原则”——3 份数据、2 种介质、1 份异地。听起来夸张，但真丢过数据的人都会照做。

  ③ 记录配置。 Docker 容器的端口、挂载路径、环境变量，拿个文档记下来。重装或迁移时能省下大量时间。

  ④ 别把 NAS 当唯一存储。 硬盘有寿命，任何单点都可能失效。重要的东西永远至少两份。

  ⑤ 看硬盘温度。 fnOS 里能看到每块盘的温度。长期超过 45℃ 就该处理了——加风扇、改风道、或者把机箱挪到通风的地方。

  ⑥ 定期看 SMART 信息。 硬盘快坏之前通常有征兆（重映射扇区数上升、寻道错误增加）。fnOS 的存储页面能看到，或者用 smartctl -a /dev/sdX 手动查。发现预警就尽早换盘，别等它真坏。

  ⑦ 风扇和除尘。 机械硬盘怕热也怕震。机箱通风做好的话，盘能多活好几年。半年清一次灰。

]]> https://primerusse.top/2026/09/20/202609200200/ 2026-09-19T18:00:00.000Z 从 DIY 机箱选型到装系统、配存储与远程访问。 用 fnOS 搭一台自己的 NAS 2026-09-19T18:00:00.000Z Primerusse 1 先说结论

  重装系统这件事，卡住大多数人的不是装的过程，而是做启动盘。而做启动盘的工具，绕不开 Rufus 和 Ventoy 这两个。

  如果你只装一次系统，用 Rufus：把一个 ISO 写进 U 盘，U 盘就变成这块 ISO 的专用启动盘，简单直接。

  如果你手上有一堆 ISO（Windows 10、Windows 11、几个 Linux 发行版、还有 PE 维护盘），用 Ventoy：U 盘只格式化一次，之后把 ISO 文件直接复制进去就能启动，想加哪个加哪个。

  一句话：Rufus 是“一次一个”，Ventoy 是“一个装一堆”。

2 相关网站

2.1 工具官网

工具官网说明
Rufushttps://rufus.ie/官网首页就带下载链接，直接给 exe
Ventoyhttps://www.ventoy.net/cn/官网有中文版，下载页 https://www.ventoy.net/cn/download.html

  只从官网下载。 Rufus 和 Ventoy 都是绿色软件，网上有大量二次打包的版本，夹带私货的不在少数。

2.2 系统镜像下载

  镜像来源分两类：官方原版和第三方整理站。

  微软官方（最干净，但下载慢）：

系统地址
Windows 11https://www.microsoft.com/software-download/windows11
Windows 10https://www.microsoft.com/software-download/windows10

  ITELLU（NEXT, ITELLYOU）：国内最常用的原版镜像整理站，收录微软各版本系统、Office 等，只提供原版镜像和校验值，不夹带任何修改。目前有两个站点：

站点地址说明
NEXT, ITELLYOUhttps://next.itellyou.cn/新版站点，界面重做过，需要登录
MSDN, 我告诉你https://msdn.itellyou.cn/老版站点，界面朴素但胜在直接

  两个站是同一个团队维护，内容一致。新版（next）的界面更清爽，还提供 ed2k 和磁力链接；老版（msdn）打开更快，找老系统（比如 Windows 7、Office 2013）时反而更方便。

  怎么用：进去选“操作系统”→ 选版本 → 展开详情，会看到 ed2k:// 开头的链接和 SHA1 值。ed2k 链接需要用支持 ed2k 的下载工具；新版站点也提供直接下载。

  Linux 发行版直接从各家官网下：Ubuntu https://ubuntu.com/download、Debian https://www.debian.org/distrib/、Fedora https://fedoraproject.org/workstation/download。

2.3 一定要校验

  镜像下载中断、被 CDN 篡改、下到了别人改过的包——这些都会导致装出来的系统有问题，而且症状很隐蔽（装到一半报错、装完某些功能异常）。

  解决办法是下完就对哈希值。Windows 上在 PowerShell 里跑：

1
Get-FileHash -Algorithm SHA256 "D:\Win11_24H2.iso"

  Linux / macOS：

1
2
3
sha256sum Win11_24H2.iso
# macOS
shasum -a 256 Win11_24H2.iso

  把输出和站点上标的 SHA256（老站给的是 SHA1）对一下。只要有一位不一样，就重新下载。

  注意：ITELLU 老站给的是 SHA1，新站给的是 SHA256，两者算法不同，别拿一个算法的值去对另一个。要校验 SHA1 的话把上面命令的 -Algorithm SHA256 换成 -Algorithm SHA1。

3 两者的区别

RufusVentoy
工作原理把 ISO 解压写入 U 盘在 U 盘装一个引导器，ISO 保持原文件放在里面
一个 U 盘装几个系统1 个不限（取决于 U 盘容量）
加新 ISO要重新写入，原数据全没直接把 ISO 复制进去
U 盘平时能否当普通 U 盘用基本不能（被占用）可以，剩的空间随便放文件
启动兼容性极好，几乎通吃很好，但个别老机器或特殊 ISO 要额外设置
是否要装软件要（Windows 上的绿色小工具）只需装一次到 U 盘，之后免安装
是否开源开源（GPLv3）开源（GPLv3）
体积约 1.5 MB约 20 MB（含引导器）
适合谁偶尔装一次系统经常折腾、装机、维护

  还有个容易被忽略的点：Rufus 写入后的 U 盘，剩余空间虽然能用，但文件系统和分区结构会被改成启动盘的样子，有些老主板认它当光驱。而 Ventoy 的分区结构是固定的，镜像都放在一个大分区里，当普通 U 盘用毫无问题。

  另外说一下为什么 Rufus 兼容性更好。它写入时会按 ISO 的类型自动选择引导方式（Windows 用 bootmgr、Linux 用 GRUB/isolinux），并且能处理 UEFI 和 Legacy BIOS 两种固件。Ventoy 是在 U 盘上先启动自己的引导器，再由引导器去加载 ISO，中间多了一层——好处是灵活，代价是个别镜像需要手动指定引导方式。

4 Rufus 的用法

4.1 准备

  需要三样东西：

  （1）一个 8GB 以上的 U 盘（装 Windows 11 建议 16GB，新的 Win11 镜像解压后接近 6GB）。里面的数据会全部丢失，先备份。

  （2）系统镜像 ISO，从上面列的渠道下载并校验。

  （3）Rufus 本体，从 https://rufus.ie/ 下载。它是绿色软件，下载后双击就能用，不用安装。

4.2 操作步骤

  （1）插入 U 盘，打开 Rufus。它会自动识别到你的 U 盘。

  先确认“设备”那一栏选的是你的 U 盘，不是移动硬盘、不是别的盘。选错盘会把那块盘整个清空，这个错误一旦犯下就无法撤销。

  （2）点“选择”按钮，选中下载好的 ISO。

  （3）分区类型按你的主板选：

你的电脑分区类型目标系统
2012 年后的主流机型GPTUEFI
很老的机器MBRBIOS

  不确定的话，进 BIOS 看一眼是 UEFI 还是 Legacy。现在的新机器基本都是 GPT + UEFI。

  选 GPT 时，Rufus 有时还会让你选“目标系统”是 UEFI 还是 UEFI(CSM)。选纯 UEFI，除非你要装的是很老的系统。

  （4）点“开始”。Rufus 会弹几个选项：

  ——如果装 Windows 11，它会问是否跳过 TPM 和安全启动检查。老机器想装 Win11 就勾上。
  ——如果 ISO 是 Windows，它还会问用什么账户。想跳过微软账户登录就选“本地账户”。
  ——如果目标盘已有数据，它会再确认一次分区方案。

  （5）等进度条走完。耗时取决于 U 盘速度，一般 5～15 分钟。USB 3.0 接口 + USB 3.0 U 盘通常 3～5 分钟就够；插在 USB 2.0 口上可能要 20 分钟以上。

  （6）完成后拔掉 U 盘，插到目标电脑上，开机时按启动菜单键选择从 U 盘启动。

4.3 进不去启动菜单怎么办

  两种情况：

  ——按了键没反应：多半是没按对时机。开机瞬间连按，或者干脆先按住再按电源键。
  ——菜单里看不到 U 盘：进 BIOS 关掉“快速启动”（Fast Boot）——它会跳过 USB 设备检测；或者把“安全启动”（Secure Boot）暂时关掉。

  各品牌机器的按键：

品牌启动菜单进 BIOS
华硕 / 微星 / 技嘉（主板）F8 / F11 / F12Del
联想（笔记本）F12F2 或 Fn+F2
联想（台式 / ThinkCentre）F12F1
戴尔F12F2
惠普F9F10 或 Esc
宏碁F12F2
华为 / 荣耀F12F2

  不确定的话，开机画面上一般会写“Press XX to enter Boot Menu”。

5 Ventoy 的用法

5.1 装到 U 盘（只需一次）

  （1）从 https://www.ventoy.net/cn/download.html 下载，解压后运行 Ventoy2Disk.exe（Windows）或 Ventoy2Disk.sh（Linux）。

  （2）选中你的 U 盘。同样要确认选对了盘。

  （3）分区类型同样按主板选 GPT / MBR。旁边还有个“安全启动支持”的选项——要装的机器开了 Secure Boot 就勾上，否则会启动失败。

  （4）点“安装”。这一步会清空 U 盘。

  （5）装完后，U 盘会多出一个叫 Ventoy 的分区。这个分区就是用来放 ISO 的。

  （6）装完不要再点“安装”，否则又会清空一次。以后升级 Ventoy 版本用“升级”按钮——升级不会清空数据。

  如果装完发现 U 盘总容量比标称少了很多，这是正常的：Ventoy 会占用一部分空间放引导程序和 EFI 分区。新版本（1.0.80 之后）默认使用整个 U 盘建一个大分区，容量基本不会大幅缩水。

5.2 加系统镜像

  这一步简单到不像话：把 ISO 文件复制到 Ventoy 分区里就行。

  可以建文件夹分类，比如：

1
2
3
4
5
6
7
8
9
Ventoy/
├── Windows/
│   ├── Win11_24H2.iso
│   └── Win10_22H2.iso
├── Linux/
│   ├── ubuntu-24.04.iso
│   └── debian-12.iso
└── PE/
    └── WePE.iso

  复制完拔盘就能用。想删就删，想加就加，U 盘当普通存储用也完全没问题。

  放 ISO 的文件夹可以自定义。 默认根目录下所有 ISO 都会被列出；如果只想让某个目录的镜像出现在菜单里，可以在“配置选项”里设置搜索目录。

5.3 启动与选择

  插上 U 盘启动，Ventoy 会列出你放进去的所有 ISO，用方向键选一个回车即可。

  如果某个 ISO 启动失败，选中它之后先按 F1，会切到 grub2 模式再回车。Ventoy 对特殊镜像提供了多种引导方式，挨个试基本能找到能用的：

按键作用
F1切换 grub2 模式
F2切换 wimboot 模式（Windows 专用）
F3切换 memdisk 模式
F4从本地硬盘启动（跳过 U 盘）
F5调试模式（排查启动问题）
F6进入 Ventoy 插件模式

  还有个“持久化”（Persistence）功能：给 Live 版 Linux 分配一块可写的存储空间，这样用它启动后做的修改能保存下来。需要在 U 盘上放一个配置文件，具体见官网文档。

6 该选哪个

  装一次系统就完事：Rufus。省事，兼容性最好。

  经常装机、维护、玩不同发行版：Ventoy。一个 U 盘走天下，这是它最大的价值。

  两个都留着也不冲突：我自己是一个 32GB U 盘装 Ventoy 放常用镜像，另外拿个旧的小 U 盘用 Rufus 写单个系统，专门对付那些 Ventoy 引导不起来的机器。

  容量怎么分配比较合适：

U 盘容量建议
8GB只够 Rufus 写一个 Windows 11
16GBVentoy + 2～3 个系统
32GBVentoy + 4～6 个系统 + PE 盘（推荐）
64GB 以上可以连 Linux 发行版一起塞进去

7 装系统的完整流程

  做完启动盘，后面还有几步。这里顺一下完整流程，避免漏环节。

7.1 装之前：备份

  这一步不能省。 重装会清空 C 盘（如果整盘重装，所有数据都没）。

  要备份的东西：

  ——桌面、文档、下载里的文件（很多人只记得备份前两个）。
  ——浏览器的书签和密码。Chrome / Edge 登录账号后会自动同步，但最好导出成 HTML 存一份。
  ——微信 / QQ 的聊天记录。微信默认存在 C:\Users\<用户名>\Documents\WeChat Files，在 C 盘，重装就没了。记得手动备份或改到别的盘。
  ——各种软件的授权码 / 配置文件。
  ——网卡驱动。特别是一些老机器，网卡驱动如果不在系统里，装完系统会连不上网——这是个死循环。提前把网卡驱动下载到 U 盘的另一个分区里。

7.2 装的过程中

  （1）从 U 盘启动，进安装界面。

  （2）选择“自定义安装”（不要选“升级”，那不会清空旧系统）。

  （3）到分区这一步，注意别选错盘。想彻底重装就把目标盘的分区全删掉，让安装程序自己建；想保留别的盘的数据，就只删系统分区。

  （4）装完会重启几次。第一次重启时把 U 盘拔掉，否则可能又从 U 盘启动，陷入循环。

7.3 装完之后

  （1）进 BIOS 把启动顺序调回硬盘。 不然每次开机都要插 U 盘或者手动选。

  （2）连网、装驱动。Windows 10/11 联网后会自动装大部分驱动，剩下的去主板 / 笔记本官网下。

  （3）激活。品牌的机器一般 BIOS 里内置了数字许可证，联网自动激活；自己装的机器需要密钥。

  （4）装完先做个系统还原点或镜像备份，以后再出问题能快速恢复。

8 几个踩过的坑

  ① U 盘选错，数据全没。 Rufus 和 Ventoy 选定盘符那一步一定要看清楚。已经出过太多次这种事——认盘符不如认容量，看到容量不对立刻停手。

  ② ISO 下到一半的文件。 下载中断的 ISO 大小不对，写进去启动会报错，而且报错信息五花八门。写完对一下文件大小和哈希值。

  ③ Win11 装不上，提示不满足要求。 除了 TPM，还要注意 Rufus 里那个“跳过检查”的选项要勾；用 Ventoy 的话要在 BIOS 里关 Secure Boot，或者在安装时按 Shift+F10 打开命令行手动绕过。

  ④ 装完系统启动顺序还停在 U 盘。 装完记得拔 U 盘，或进 BIOS 把硬盘调回第一位，否则会一直从 U 盘启动。

  ⑤ U 盘写完容量变小。 这是正常的——启动盘的分区结构和普通 U 盘不同。想恢复成普通 U 盘，用 Windows 的“磁盘管理”（diskmgmt.msc）把分区全删了重新建一个即可。

  ⑥ Ventoy 装完提示“不是可引导的设备”。 多半是 U 盘本身的问题——有些杂牌 U 盘的主控不支持 Ventoy 需要的分区结构。换一个品牌的 U 盘试试。如果这个 U 盘以前被量产工具改过，建议先用 diskpart 的 clean 命令彻底清一次。

  ⑦ 老机器认不出 GPT 的 U 盘。 老机器只支持 Legacy BIOS，U 盘必须做成 MBR + BIOS。反过来，新机器用 MBR 的 U 盘通常也能启动（走 CSM 兼容模式），但装出来的系统可能无法发挥 UEFI 的优势。

  ⑧ 装完系统发现少了一个盘。 常见于从 RAID 或动态磁盘迁移过来的机器。进“磁盘管理”看看是不是有未分配或未初始化磁盘——别急着点“初始化”，那会丢数据，先确认那块盘上有没有要保留的内容。

]]> https://primerusse.top/2026/09/20/202609200100/ 2026-09-19T17:00:00.000Z 两种启动盘方案的对比、镜像下载渠道与完整操作步骤。 如何重装系统：Rufus 与 Ventoy 怎么选 2026-09-19T17:00:00.000Z Primerusse 1 绪论

  斐波那契数列定义为 F0=0F_0=0，F1=1F_1=1，Fn=Fn−1+Fn−2 (n≥2)F_n=F_{n-1}+F_{n-2}\ (n\geq 2)。它是一个二阶线性递推数列，通项公式（比内公式）为

Fn=15[(1+52)n−(1−52)n]F_n=\frac{1}{\sqrt{5}}\left[\left(\frac{1+\sqrt{5}}{2}\right)^n-\left(\frac{1-\sqrt{5}}{2}\right)^n\right]

  这个式子本身并不复杂，但导出它的路径有很多条。本文用 6 种方法分别推导，它们从不同角度切入，最终都落到同一个公式：

方法切入点
特征方程法猜测解为指数形式 rnr^n，把递推式化为特征方程 r2−r−1=0r^2-r-1=0
生成函数法把数列打包成幂级数 F(x)=∑FnxnF(x)=\sum F_nx^n，解出 F(x)F(x) 后展开取系数
矩阵法把递推写成矩阵幂 (1110)n\begin{pmatrix}1&1\\1&0\end{pmatrix}^n，再对角化
移位算子法引入移位算子 EE，把递推式当作算子方程求解
构造等比数列法凑出两个等比子列，用它们的线性组合表示 FnF_n
无穷连分数法由相邻项之比满足的关系得到连分数，取其收敛值

  对同一个问题给出多种解法，价值不在于重复劳动，而在于同一个数学对象在不同语言（差分方程、幂级数、线性代数、算子、连分数）中的不同面貌。下面逐一推导。

2 特征方程法

  对于F0=0F_0=0，F1=1F_1=1，Fn=Fn−1+Fn−2(n≥2)F_n=F_{n-1}+F_{n-2}(n\geq 2)，假设解FnF_n的基本形式。

  ①常数，Fn=CF_n=C。C=C+C⇒C=0C=C+C\Rightarrow C=0，不符。

  ②一次函数，Fn=rn+sF_n=rn+s，rn+s=r(n−1)+s+r(n−2)+s⇒n=3−srrn+s=r(n-1)+s+r(n-2)+s\Rightarrow n=3-\frac{s}{r}，不符。

  ③三角函数，Fn=sin(n)F_n=sin(n)。sin(n)=sin(n−1)+sin(n−2)sin(n)=sin(n-1)+sin(n-2)，不符。

  ④对数函数，Fn=ln(n)F_n=ln(n)。ln(n)=ln(n−1)+ln(n−2)ln(n)=ln(n-1)+ln(n-2)，不符。

  ⑤指数函数，Fn=rnF_n=r^n。rn=rn−1+rn−2⇒r2=r+1⇒r2−r−1=0r^n=r^{n-1}+r^{n-2}\Rightarrow r^2=r+1\Rightarrow r^2-r-1=0，可能满足。

  故猜测Fn=rnF_n=r^n，并且rr满足r2−r−1=0r^2-r-1=0。

  rr有两个解，r1=1+52r_1=\frac{1+\sqrt{5}}{2}，r2=1−52r_2=\frac{1-\sqrt{5}}{2}。

  FnF_n通解即为两个线性无关解的组合。

Fn=Ar1n+Br2nF_n=Ar_1^n+Br_2^n

  当n=0n=0时，F0=A+B=0⇒B=−AF_0=A+B=0\Rightarrow B=-A。

  当n=1n=1时，F1=Ar1+Br2=1F_1=Ar_1+Br_2=1，带入B=−AB=-A，得

A(r1−r2)=1⇒A=15⇒B=−15A(r_1-r_2)=1\Rightarrow A=\frac{1}{\sqrt{5}}\Rightarrow B=-\frac{1}{\sqrt{5}}

  代入Fn=Ar1n+Br2nF_n=Ar_1^n+Br_2^n得，

Fn=15[(1+52)n−(1−52)n]F_n=\frac{1}{\sqrt{5}}\left[\left(\frac{1+\sqrt{5}}{2}\right)^n-\left(\frac{1-\sqrt{5}}{2}\right)^n\right]

  代入n=0n=0和n=1n=1验证，满足条件。

3 生成函数法

  对于F0=0F_0=0，F1=1F_1=1，Fn=Fn−1+Fn−2(n≥2)F_n=F_{n-1}+F_{n-2}(n\geq 2)，定义

F(x)=∑n=0∞Fnxn=F0+F1x+F2x2+F3x3+...F(x)=\sum_{n=0}^{\infty}F_nx^n=F_0+F_1x+F_2x^2+F_3x^3+...

  等式两边同时乘xx，x2x^2，并于原式比较，

F(x)=F0+F1x+F2x2+F3x3+...x⋅F(x)=F0x+F1x2+F2x3+F3x4+...x2⋅F(x)=F0x2+F1x3+F2x4+F3x5+...\begin{aligned} F(x) &=F_0 + \hspace{-1em}&&F_1x + &&\hspace{-1em}F_2x^2 + &&\hspace{-1em}F_3x^3 + &&\hspace{-1em}...\\ x\cdot F(x) &= &&F_0x + &&\hspace{-1em}F_1x^2 + &&\hspace{-1em}F_2x^3 + &&\hspace{-1em}F_3x^4 + &&\hspace{-1em}...\\ x^2\cdot F(x)&= && &&\hspace{-1em}F_0x^2 + &&\hspace{-1em}F_1x^3 + &&\hspace{-1em}F_2x^4 + &&\hspace{-1em}F_3x^5 + &&\hspace{-1em}...\end{aligned}

  故有，

(1−x−x2)F(x)=F0+F1x−F0x+∑n=2∞(Fn−Fn−1−Fn−2)xn=F0+F1x−F0x=x\begin{aligned} (1-x-x^2)F(x)&=F_0+F_1x-F_0x+\sum_{n=2}^{\infty}(F_n-F_{n-1}-F_{n-2})x^n\\ &=F_0+F_1x-F_0x\\ &=x\end{aligned}

  即，

F(x)=x1−x−x2F(x)=\frac{x}{1-x-x^2}

  尝试将分母1−x−x21-x-x^2因式分解，令

1−x−x2=01-x-x^2=0

  解得，

x1=−1+52，x2=−1−52x_1=\frac{-1+\sqrt{5}}{2}，x_2=\frac{-1-\sqrt{5}}{2}

  故有，

1−x−x2=−(x−−1+52)⋅(x−−1−52)=−(−1+52⋅−1−52)(x⋅2−1+5−−1+52⋅2−1+5)⋅(x⋅2−1−5−−1−52⋅2−1−5)=(1+52x−1)⋅(1−52x−1)=(1−1+52x)⋅(1−1−52x)\begin{aligned} 1-x-x^2=&-\left(x-\frac{-1+\sqrt{5}}{2}\right)\cdot\left(x-\frac{-1-\sqrt{5}}{2}\right)\\ =&-\left(\frac{-1+\sqrt{5}}{2}\cdot\frac{-1-\sqrt{5}}{2}\right)\left(x\cdot\frac{2}{-1+\sqrt{5}}-\frac{-1+\sqrt{5}}{2}\cdot\frac{2}{-1+\sqrt{5}}\right)\cdot\\ &\left(x\cdot\frac{2}{-1-\sqrt{5}}-\frac{-1-\sqrt{5}}{2}\cdot\frac{2}{-1-\sqrt{5}}\right)\\ =&\left(\frac{1+\sqrt{5}}{2}x-1\right)\cdot\left(\frac{1-\sqrt{5}}{2}x-1\right)\\ =&\left(1-\frac{1+\sqrt{5}}{2}x\right)\cdot\left(1-\frac{1-\sqrt{5}}{2}x\right)\end{aligned}

  设

F(x)=x1−x−x2=A1−1+52x+B1−1−52xF(x)=\frac{x}{1-x-x^2}=\frac{A}{1-\frac{1+\sqrt{5}}{2}x}+\frac{B}{1-\frac{1-\sqrt{5}}{2}x}

  通分得，

F(x)=A(1−1−52x)+B(1−1+52x)1−x−x2=(A+B)−(A⋅1−52+B⋅1+52)x1−x−x2=x1−x−x2\begin{aligned} F(x)&=\frac{A\left(1-\frac{1-\sqrt{5}}{2}x\right)+B\left(1-\frac{1+\sqrt{5}}{2}x\right)}{1-x-x^2}\\ &=\frac{(A+B)-\left(A\cdot\frac{1-\sqrt{5}}{2}+B\cdot\frac{1+\sqrt{5}}{2}\right)x}{1-x-x^2}\\ &=\frac{x}{1-x-x^2}\end{aligned}

  可得，A=15=−BA=\frac{1}{\sqrt{5}}=-B。

  故有，

F(x)=15[11−1+52x−11−1−52x]F(x)=\frac{1}{\sqrt{5}}\left[\frac{1}{1-\frac{1+\sqrt{5}}{2}x}-\frac{1}{1-\frac{1-\sqrt{5}}{2}x}\right]

  由几何级数

11−ax=∑n=0∞anxn\frac{1}{1-ax}=\sum_{n=0}^{\infty}a^nx^n

  得

F(x)=15∑n=0∞[(1+52)n−(1−52)n]xnF(x)=\frac{1}{\sqrt{5}}\sum_{n=0}^{\infty}\left[\left(\frac{1+\sqrt{5}}{2}\right)^n-\left(\frac{1-\sqrt{5}}{2}\right)^n\right]x^n

  与F(x)=∑n=0∞FnxnF(x)=\sum_{n=0}^{\infty}F_nx^n比较系数，得

Fn=15[(1+52)n−(1−52)n]F_n=\frac{1}{\sqrt{5}}\left[\left(\frac{1+\sqrt{5}}{2}\right)^n-\left(\frac{1-\sqrt{5}}{2}\right)^n\right]

4 矩阵法

  对于F0=0F_0=0，F1=1F_1=1，Fn=Fn−1+Fn−2(n≥2)F_n=F_{n-1}+F_{n-2}(n\geq 2)，有

Fn=1⋅Fn−1+1⋅Fn2Fn−1=1⋅Fn−1+0⋅Fn2\begin{aligned} F_n &=1\cdot F_{n-1}+1\cdot F_{n_2}\\ F_{n-1}&=1\cdot F_{n-1}+0\cdot F_{n_2}\end{aligned}

  写成矩阵，

(FnFn−1)=(1110)(Fn−1Fn−2)\begin{aligned} \begin{pmatrix} F_n \\ F_{n-1} \end{pmatrix} = \begin{pmatrix} 1 & 1 \\ 1 & 0 \end{pmatrix} \begin{pmatrix} F_{n-1} \\ F_{n-2} \end{pmatrix}\end{aligned}

  记

M=(1110)M=\begin{pmatrix} 1 & 1 \\ 1 & 0\end{pmatrix}

  故有

(FnFn−1)=M(Fn−1Fn−2)=M2(Fn−2Fn−3)=...=Mn−1(F1F0)\begin{aligned} \begin{pmatrix} F_n \\ F_{n-1} \end{pmatrix} = M \begin{pmatrix} F_{n-1} \\ F_{n-2} \end{pmatrix} = M^2 \begin{pmatrix} F_{n-2} \\ F_{n-3} \end{pmatrix} =... = M^{n-1} \begin{pmatrix} F_1 \\ F_0 \end{pmatrix}\end{aligned}

  代入F0=0F_0=0，F1=1F_1=1，

(FnFn−1)=Mn−1(10)\begin{aligned} \begin{pmatrix} F_n \\ F_{n-1} \end{pmatrix} = M^{n-1} \begin{pmatrix} 1 \\ 0 \end{pmatrix}\end{aligned}

  不难发现，只需要求出Mn−1M^{n-1}即可求出FnF_n。

  计算M=(1110)M=\begin{pmatrix} 1 & 1 \\ 1 & 0\end{pmatrix}的特征值与特征向量，

λ1=1+52，λ2=1−52\lambda_1=\frac{1+\sqrt{5}}{2}，\lambda_2=\frac{1-\sqrt{5}}{2}

φ1=(λ11)，φ2=(λ21)\begin{aligned} \varphi_1= \begin{pmatrix} \lambda_1 \\ 1 \end{pmatrix} ， \varphi_2= \begin{pmatrix} \lambda_2 \\ 1 \end{pmatrix}\end{aligned}

  对角化矩阵MM,

M=PDP−1M=PDP^{-1}

  其中，

P=(φ1φ2)=(λ1λ211)\begin{aligned} P= \begin{pmatrix} \varphi_1 & \varphi_2 \end{pmatrix} = \begin{pmatrix} \lambda_1 & \lambda_2 \\ 1 & 1 \end{pmatrix}\end{aligned}

D=(λ100λ2)\begin{aligned} D= \begin{pmatrix} \lambda_1 & 0 \\ 0 & \lambda_2 \end{pmatrix}\end{aligned}

P−1=15(1−λ2−1λ1)\begin{aligned} P^{-1}=\frac{1}{\sqrt{5}} \begin{pmatrix} 1 & -\lambda_2 \\ -1 & \lambda_1 \end{pmatrix}\end{aligned}

  由对角化的性质，可得

Mn−1=PDn−1P−1=15(λ1λ211)(λ1n−100λ2n−1)(1−λ2−1λ1)=15(λ1nλ2nλ1n−1λ2n−1)(1−λ2−1λ1)\begin{aligned} M^{n-1}=PD^{n-1}P^{-1}&=\frac{1}{\sqrt{5}} \begin{pmatrix} \lambda_1 & \lambda_2 \\ 1 & 1 \end{pmatrix} \begin{pmatrix} \lambda_1^{n-1} & 0 \\ 0 & \lambda_2^{n-1} \end{pmatrix} \begin{pmatrix} 1 & -\lambda_2 \\ -1 & \lambda_1 \end{pmatrix}\\ &=\frac{1}{\sqrt{5}} \begin{pmatrix} \lambda_1^n & \lambda_2^n \\ \lambda_1^{n-1} & \lambda_2^{n-1} \end{pmatrix} \begin{pmatrix} 1 & -\lambda_2 \\ -1 & \lambda_1 \end{pmatrix}\end{aligned}

  故有

(FnFn−1)=Mn−1(10)=15(λ1nλ2nλ1n−1λ2n−1)(1−λ2−1λ1)(10)=15(λ1nλ2nλ1n−1λ2n−1)(1−1)=15(λ1n−λ2nλ1n−1−λ2n−1)\begin{aligned} \begin{pmatrix} F_n \\ F_{n-1} \end{pmatrix} = M^{n-1} \begin{pmatrix} 1 \\ 0 \end{pmatrix} &=\frac{1}{\sqrt{5}} \begin{pmatrix} \lambda_1^n & \lambda_2^n \\ \lambda_1^{n-1} & \lambda_2^{n-1} \end{pmatrix} \begin{pmatrix} 1 & -\lambda_2 \\ -1 & \lambda_1 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \end{pmatrix}\\ &=\frac{1}{\sqrt{5}} \begin{pmatrix} \lambda_1^n & \lambda_2^n \\ \lambda_1^{n-1} & \lambda_2^{n-1} \end{pmatrix} \begin{pmatrix} 1 \\ -1 \end{pmatrix}\\ &=\frac{1}{\sqrt{5}} \begin{pmatrix} \lambda_1^n-\lambda_2^n \\ \lambda_1^{n-1}-\lambda_2^{n-1} \end{pmatrix}\end{aligned}

  只看第一行，可得

Fn=15(λ1n−λ2n)F_n=\frac{1}{\sqrt{5}}(\lambda_1^n-\lambda_2^n)

  即

Fn=15[(1+52)n−(1−52)n]F_n=\frac{1}{\sqrt{5}}\left[\left(\frac{1+\sqrt{5}}{2}\right)^n-\left(\frac{1-\sqrt{5}}{2}\right)^n\right]

5 移位算子法

  对于F0=0F_0=0，F1=1F_1=1，Fn=Fn−1+Fn−2(n≥2)F_n=F_{n-1}+F_{n-2}(n\geq 2)，定义移位算子EE

EFn=Fn+1EF_n=F_{n+1}

  故有

E2Fn=EFn+1=Fn+2E^2F_n=EF_{n+1}=F_{n+2}

  同理可得，

EkFn=Fn+kE^kF_n=F_{n+k}

  同时，也可以看出

Fn=EnF0=EnF_n=E^nF_0=E^n

  由Fn=Fn−1+Fn−2F_n=F_{n-1}+F_{n-2}得

Fn=EFn+E2Fn⇒(E2+E−1)Fn=0F_n=EF_n+E^2F_n\Rightarrow(E^2+E-1)F_n=0

  由于FnF_n不恒为00，故有

E2+E−1=0E^2+E-1=0

  解方程，得

E1=1+52，E2=1−52E_1=\frac{1+\sqrt{5}}{2}，E_2=\frac{1-\sqrt{5}}{2}

  对于特解E1E_1，我们有Fn=E1nF_n=E_1^n。对于特解E2E_2，我们有Fn=E2nF_n=E_2^n。

  故EE得通解应为

En=AE1n+BE2nE^n=AE_1^n+BE_2^n

  当n=0n=0时，F0=E0=A+B=0F_0=E^0=A+B=0。

  当n=1n=1时，F1=E1=AE1+BE2F_1=E^1=AE_1+BE_2。

  可得，A=15=−BA=\frac{1}{\sqrt{5}}=-B

  故有

Fn=En=15[(1+52)n−(1−52)n]F_n=E^n=\frac{1}{\sqrt{5}}\left[\left(\frac{1+\sqrt{5}}{2}\right)^n-\left(\frac{1-\sqrt{5}}{2}\right)^n\right]

6 构造等比数列法

  对于F0=0F_0=0，F1=1F_1=1，Fn=Fn−1+Fn−2(n≥2)F_n=F_{n-1}+F_{n-2}(n\geq 2)，假设可以凑出以下形式

Fn−pFn−1=q(Fn−1−pFn−2)F_n-pF_{n-1}=q(F_{n-1}-pF_{n-2})

  并且令

Gn=Fn−pFn−1G_n=F_n-pF_{n-1}

  故有

Gn=qGn−1G_n=qG_{n-1}

  这是一个首项G0=1G_0=1，公比为qq的等比数列。可以求得

Gn=qn−1G_n=q^{n-1}

  将凑的式子Fn−pFn−1=q(Fn−1−pFn−2)F_n-pF_{n-1}=q(F_{n-1}-pF_{n-2})化简，得

Fn=(p+q)Fn−1−pqFn−2F_n=(p+q)F_{n-1}-pqF_{n-2}

  与Fn=Fn−1+Fn−2F_n=F_{n-1}+F_{n-2}对比系数，得

{p+q=1pq=−1\begin{aligned} \begin{cases} p + q&=1\\ \quad pq&=-1 \end{cases}\end{aligned}

  解得

{p=1+52q=1−52或{p=1−52q=1+52\begin{aligned} \begin{cases} p=\frac{1+\sqrt{5}}{2}\\ q=\frac{1-\sqrt{5}}{2} \end{cases} \quad 或\quad \begin{cases} p=\frac{1-\sqrt{5}}{2}\\ q=\frac{1+\sqrt{5}}{2} \end{cases}\end{aligned}

  令

{s1=1+52s2=1−52\begin{aligned} \begin{cases} s_1=\frac{1+\sqrt{5}}{2}\\ s_2=\frac{1-\sqrt{5}}{2} \end{cases}\end{aligned}

  故

{p=s1q=s2或{p=s2q=s1\begin{aligned} \begin{cases} p=s_1\\ q=s_2 \end{cases} \quad 或\quad \begin{cases} p=s_2\\ q=s_1 \end{cases}\end{aligned}

  当p=s1，q=s2p=s_1，q=s_2时，有Gn=Fn−pFn−1=qn−1G_n=F_n-pF_{n-1}=q^{n-1}，即Fn−s1Fn−1=s2n−1①F_n-s_1F_{n-1}=s_2^{n-1}①。

  当p=s2，q=s1p=s_2，q=s_1时，有Gn=Fn−pFn−1=qn−1G_n=F_n-pF_{n-1}=q^{n-1}，即Fn−s2Fn−1=s1n−1②F_n-s_2F_{n-1}=s_1^{n-1}②。

  ①⋅s2−②⋅s1①\cdot s_2-②\cdot s_1得，(s2−s1)=Fn=s2n−s1n(s_2-s_1)=F_n=s_2^n-s_1^n，即

Fn=s2n−s1ns2−s1F_n=\frac{s_2^n-s_1^n}{s_2-s_1}

  代入s1s_1和s2s_2得

Fn=15[(1+52)n−(1−52)n]F_n=\frac{1}{\sqrt{5}}\left[\left(\frac{1+\sqrt{5}}{2}\right)^n-\left(\frac{1-\sqrt{5}}{2}\right)^n\right]

7 无穷连分数法

  对于F0=0F_0=0，F1=1F_1=1，Fn=Fn−1+Fn−2(n≥2)F_n=F_{n-1}+F_{n-2}(n\geq 2)，我们对Fn=Fn−1+Fn−2F_n=F_{n-1}+F_{n-2}等式两边同时除以Fn−1F_{n-1}，得

FnFn−1=1+Fn−2Fn−1\frac{F_n}{F_{n-1}}=1+\frac{F_{n-2}}{F_{n-1}}

  令

xn=FnFn−1x_n=\frac{F_n}{F_{n-1}}

  故有

xn=1+1xn−1x_n=1+\frac{1}{x_{n-1}}

  将上式一直迭代，得

xn=1+1xn−1=1+11+1xn−2=1+11+11+1xn−3=...x_n=1+\frac{1}{x_{n-1}}=1+\frac{1}{1+\frac{1}{x_{n-2}}}=1+\frac{1}{1+\frac{1}{1+\frac{1}{x_{n-3}}}}=...

  取极限

φ=lim⁡n→∞xn=1+11+11+1⋱\varphi=\lim_{n\rightarrow\infty}x_n=1+\frac{1}{1+\frac{1}{1+\frac{1}{\ddots}}}

  故有

φ=1+1φ\varphi=1+\frac{1}{\varphi}

  取φ>0\varphi>0解得

φ=1+52\varphi=\frac{1+\sqrt{5}}{2}

  现在证

φn=φFn+Fn−1\varphi^n=\varphi F_n+F_{n-1}

  成立，用归纳法。

  由φ=1+1φ\varphi=1+\frac{1}{\varphi}得，

φ2=φ+1\varphi^2=\varphi+1

  当n=1n=1时，有φ1=φF1+F0\varphi^1=\varphi F_1+F_0成立；

  当n=kn=k且φk−1=φFk−1+Fk−2\varphi^{k-1}=\varphi F_{k-1}+F_{k-2}时，

φk−1=φFk−1+Fk−2⇒φk=φ2Fk−1+φFk−2⇒φk=(φ+1)Fk−1+φFk−2⇒φk=φ(Fk−1+Fk−2)+Fk−1⇒φk=φFk+Fk−1\begin{aligned} &\varphi^{k-1}=\varphi F_{k-1}+F_{k-2}\\ \Rightarrow&\varphi^k=\varphi^2F_{k-1}+\varphi F_{k-2}\\ \Rightarrow&\varphi^k=(\varphi+1)F_{k-1}+\varphi F_{k-2}\\ \Rightarrow&\varphi^k=\varphi(F_{k-1}+F_{k-2})+F_{k-1}\\ \Rightarrow&\varphi^k=\varphi F_k+F_{k-1}\end{aligned}

  综上，

φn=φFn+Fn−1\varphi^n=\varphi F_n+F_{n-1}

  成立。

  即

Fn=φn−1−φ−1Fn−1F_n=\varphi^{n-1}-\varphi^{-1}F_{n-1}

  继续迭代

Fn=φn−1−φ−1(φn−2−φ−2Fn−2)=φn−1−φn−3+φ−3Fn−2=φn−1−φn−3+φn−5−φ−5Fn−3=φn−1−φn−3+φn−5−φn−7+φ−7Fn−4=φn−1−φn−3+φn−5−...−(−1)nφ−n+1+(−1)nφ−2n+1F0=φn−1−φn−3+φn−5−...−(−1)nφ−n+1=φn−1[1−(−φ−2)n]1+φ−2=φn−1−(−1)nφ−n−11+φ−2=φ−11+φ−2[φn−(−1φ)n]\begin{aligned} F_n&=\varphi^{n-1}-\varphi^{-1}(\varphi^{n-2}-\varphi^{-2}F_{n-2})\\ &=\varphi^{n-1}-\varphi^{n-3}+\varphi^{-3}F_{n-2}\\ &=\varphi^{n-1}-\varphi^{n-3}+\varphi^{n-5}-\varphi^{-5}F_{n-3}\\ &=\varphi^{n-1}-\varphi^{n-3}+\varphi^{n-5}-\varphi^{n-7}+\varphi^{-7}F_{n-4}\\ &=\varphi^{n-1}-\varphi^{n-3}+\varphi^{n-5}-...-(-1)^n\varphi^{-n+1}+(-1)^n\varphi^{-2n+1}F_0\\ &=\varphi^{n-1}-\varphi^{n-3}+\varphi^{n-5}-...-(-1)^n\varphi^{-n+1}\\ &=\frac{\varphi^{n-1}[1-(-\varphi^{-2})^n]}{1+\varphi^{-2}}\\ &=\frac{\varphi^{n-1}-(-1)^n\varphi^{-n-1}}{1+\varphi^{-2}}\\ &=\frac{\varphi^{-1}}{1+\varphi^{-2}}[\varphi^{n}-(-\frac{1}{\varphi})^n]\\\end{aligned}

  代入φ=1+52\varphi=\frac{1+\sqrt{5}}{2}，得

Fn=15[(1+52)n−(1−52)n]F_n=\frac{1}{\sqrt{5}}\left[\left(\frac{1+\sqrt{5}}{2}\right)^n-\left(\frac{1-\sqrt{5}}{2}\right)^n\right]

8 方法小结

  6 种方法得出了完全相同的通项公式，但它们的性质并不相同，可按“是否需要先猜出解的形式”分两类。

  第一类：需要先猜解的形式。 特征方程法假设 Fn=rnF_n=r^n，代入后得到特征方程 r2−r−1=0r^2-r-1=0——这是最直接的一条路，但“为什么可以假设是指数形式”需要事先有判断（第 1 节中用排除法逐一试了常数、一次函数、三角函数、对数函数）。构造等比数列法本质上也是同一思路的变形：不去直接猜 FnF_n，而是凑出满足等比关系的组合。

  第二类：不需要猜，从递推式本身机械地推出来。 生成函数法把数列整体打包成幂级数，通过代数运算解出闭式，再展开取系数——整个过程不依赖任何灵感；矩阵法把递推写成矩阵幂，用线性代数中的对角化工具求解，几何意义清晰（对角化即换到特征向量基上）；移位算子法把递推式当作算子方程，形式上最接近差分方程的常规解法。无穷连分数法的路线最为特殊：它先得到相邻项之比 Fn/Fn−1F_n/F_{n-1} 的连分数表示，取其收敛值 ParseError: KaTeX parse error: Unexpected character: '' at position 1: ̲arphi=\frac{1+\…（黄金比），再反推出通项。

  值得注意的是，特征方程法中的特征根 r1=1+52r_1=\frac{1+\sqrt{5}}{2}、无穷连分数法的收敛值 φ\varphi、矩阵法中矩阵 (1110)\begin{pmatrix}1&1\\1&0\end{pmatrix} 的特征值，三者是同一个数（另一个特征根为 1−52=−1/φ\frac{1-\sqrt{5}}{2}=-1/\varphi）。这正是这些方法殊途同归的根本原因——它们都在以不同方式求解同一个特征值问题。

  由此也能看出通项公式的结构：15(r1n−r2n)\frac{1}{\sqrt{5}}(r_1^n-r_2^n) 是两个指数项之差，由于 ∣r2∣<1|r_2|<1，当 nn 较大时 r2nr_2^n 迅速衰减，FnF_n 趋近于 15r1n=φn5\frac{1}{\sqrt{5}}r_1^n=\frac{\varphi^n}{\sqrt{5}}——这也解释了为什么 FnF_n 近似按黄金比 φ≈1.618\varphi\approx1.618 成比例增长。

]]> https://primerusse.top/2026/02/22/202602220000/ 2026-02-21T16:00:00.000Z 六种方法推导斐波那契数列通项公式。 推导斐波那契数列通项公式的6种方法 2026-02-21T16:00:00.000Z Primerusse 1 实验研究背景

  钻孔卸压是冲击地压防治的常用手段：在煤层中钻孔，人为破坏局部煤体的完整性，把高应力区转移出去，从而降低冲击危险。它的施工工艺简单、成本可控，在各类煤层条件下都有应用。

  钻孔的直径、深度、间距这些单一参数，已有较多研究和现场经验可循。但钻孔怎么排布（单列、多列、交错……）对煤体内部应力传递路径和劣化规律的影响要复杂得多，相关研究还不充分——而这恰恰决定了同样数量的钻孔能否发挥最大卸压效果。

  本文用 Abaqus 做一组对照计算：在相同尺寸的煤体试件上布置 5 种不同的钻孔排布方案，其余条件完全一致，用单轴压缩下的轴向位移来比较各方案对煤体刚度的削弱程度，为钻孔排布的选择提供依据。

2 实验方法介绍

  数值模拟的适用前提是煤体在宏观尺度上可视为连续介质——其应力、应变的传递符合材料力学的基本假设。本文用 Abaqus 建立与实际煤体物理力学特性一致的模型，经有限元离散后求解其在荷载下的响应。

  流程分三步：（1）按文献与同类煤体试验数据取弹性模量、泊松比等参数，建立实体模型；（2）施加边界条件与载荷——煤柱上表面受均布轴向压力，下表面限制竖直位移与水平两个方向的转角；（3）求解并后处理，输出应力、应变、位移云图。

3 模拟实验方案

  模型尺寸：本实验采用模拟软件构建标准长方体煤体试件模型，尺寸精准设定为50mm×50mm×100mm（长×宽×高）。中间布置至少2个钻孔，孔径8mm。

  本构模型：煤体作为典型的脆性岩石类材料，在受力过程中会经历弹性变形。基于此，本实验选用弹性本构模型，具体设定如下：弹性模量2.5GPa、泊松比0.3等，上述参数组合可确保模型精准复刻目标煤体的力学特性。

  边界条件：对模型底部施加全约束，模拟煤体下部岩层的支撑作用；模型顶部不施加约束，设为自由受力面，为后续竖向加载提供受力空间。该边界条件的设计核心是还原煤体在地下开采过程中的单向受力状态（主要承受上覆岩层产生的竖向地应力，侧向应力相对较小），有效排除侧向额外应力对实验结果的干扰，确保模拟场景与工程实际受力环境的一致性，为后续加载试验的准确性提供保障。

  加载方式：结合煤矿井下地应力缓慢施加的实际工况，本实验采用单轴压缩加载方式。加载方向沿模型竖向，大小为1MPa的压强载荷。与煤体实际承受的竖向地应力方向一致。通过该加载方案，可获取煤体在受压过程中的完整荷载—位移曲线，为后续力学参数分析提供基础数据。

  试验变量：为精准探究钻孔排布形式对煤体强度的影响规律，本实验采用控制变量法，将钻孔排布形式设为唯一试验变量，其余参数（如钻孔直径、模型尺寸等）均保持一致。结合工程实际中常用的钻孔布置形式，共设计5种典型钻孔排布组合，具体方案如下：

  本文中使用的Abaqus版本是2025。

3.1 方案1（钻孔1×2）

  2个钻孔沿模型竖直中轴线分布，钻孔中心间距为30mm，距离上下边界为35mm；

  方案1 Abaqus源文件点此处下载。

图3.1 方案1（钻孔1×2）试件截面草图

图3.1 方案1（钻孔1×2）试件截面草图

  用Abaqus进行仿真，绘制的应力、应变、位移云图如下。

图3.2 方案1（钻孔1×2）试件应力云图（等轴视图）

图3.2 方案1（钻孔1×2）试件应力云图（等轴视图）

图3.3 方案1（钻孔1×2）试件应力云图（前视图）

图3.3 方案1（钻孔1×2）试件应力云图（前视图）

图3.4 方案1（钻孔1×2）试件应变云图（等轴视图）

图3.4 方案1（钻孔1×2）试件应变云图（等轴视图）

图3.5 方案1（钻孔1×2）试件应变云图（前视图）

图3.5 方案1（钻孔1×2）试件应变云图（前视图）

图3.6 方案1（钻孔1×2）试件位移云图（等轴视图）

图3.6 方案1（钻孔1×2）试件位移云图（等轴视图）

图3.7 方案1（钻孔1×2）试件位移云图（前视图）

图3.7 方案1（钻孔1×2）试件位移云图（前视图）

3.2 方案2（钻孔1×3）

  3个钻孔沿模型竖直中轴线分布，钻孔中心间距为30mm，距离上下边界为20mm；

  方案2 Abaqus源文件点此处下载。

图3.8 方案2（钻孔1×3）试件截面草图

图3.8 方案2（钻孔1×3）试件截面草图

  用Abaqus进行仿真，绘制的应力、应变、位移云图如下。

图3.9 方案2（钻孔1×3）试件应力云图（等轴视图）

图3.9 方案2（钻孔1×3）试件应力云图（等轴视图）

图3.10 方案2（钻孔1×3）试件应力云图（前视图）

图3.10 方案2（钻孔1×3）试件应力云图（前视图）

图3.11 方案2（钻孔1×3）试件应变云图（等轴视图）

图3.11 方案2（钻孔1×3）试件应变云图（等轴视图）

图3.12 方案2（钻孔1×3）试件应变云图（前视图）

图3.12 方案2（钻孔1×3）试件应变云图（前视图）

图3.13 方案2（钻孔1×3）试件位移云图（等轴视图）

图3.13 方案2（钻孔1×3）试件位移云图（等轴视图）

图3.14 方案2（钻孔1×3）试件位移云图（前视图）

图3.14 方案2（钻孔1×3）试件位移云图（前视图）

3.3 方案3（钻孔2×1）

  2个钻孔沿模型水平中轴线分布，钻孔中心间距为30mm，距离左右边界为10mm；

  方案3 Abaqus源文件点此处下载。

图3.15 方案3（钻孔2×1）试件截面草图

图3.15 方案3（钻孔2×1）试件截面草图

  用Abaqus进行仿真，绘制的应力、应变、位移云图如下。

图3.16 方案3（钻孔2×1）试件应力云图（等轴视图）

图3.16 方案3（钻孔2×1）试件应力云图（等轴视图）

图3.17 方案3（钻孔2×1）试件应力云图（前视图）

图3.17 方案3（钻孔2×1）试件应力云图（前视图）

图3.18 方案3（钻孔2×1）试件应变云图（等轴视图）

图3.18 方案3（钻孔2×1）试件应变云图（等轴视图）

图3.19 方案3（钻孔2×1）试件应变云图（前视图）

图3.19 方案3（钻孔2×1）试件应变云图（前视图）

图3.20 方案3（钻孔2×1）试件位移云图（等轴视图）

图3.20 方案3（钻孔2×1）试件位移云图（等轴视图）

图3.21 方案3（钻孔2×1）试件位移云图（前视图）

图3.21 方案3（钻孔2×1）试件位移云图（前视图）

3.4 方案4（钻孔2×2）

  4个钻孔于模型中心2×2分布，钻孔中心间距为30mm，距离左右边界为10mm，距离上下边界为35mm；

  方案4 Abaqus源文件点此处下载。

图3.22 方案4（钻孔2×2）试件截面草图

图3.22 方案4（钻孔2×2）试件截面草图

  用Abaqus进行仿真，绘制的应力、应变、位移云图如下。

图3.23 方案4（钻孔2×2）试件应力云图（等轴视图）

图3.23 方案4（钻孔2×2）试件应力云图（等轴视图）

图3.24 方案4（钻孔2×2）试件应力云图（前视图）

图3.24 方案4（钻孔2×2）试件应力云图（前视图）

图3.25 方案4（钻孔2×2）试件应变云图（等轴视图）

图3.25 方案4（钻孔2×2）试件应变云图（等轴视图）

图3.26 方案4（钻孔2×2）试件应变云图（前视图）

图3.26 方案4（钻孔2×2）试件应变云图（前视图）

图3.27 方案4（钻孔2×2）试件位移云图（等轴视图）

图3.27 方案4（钻孔2×2）试件位移云图（等轴视图）

图3.28 方案4（钻孔2×2）试件位移云图（前视图）

图3.28 方案4（钻孔2×2）试件位移云图（前视图）

3.5 方案5（钻孔2×3）

  6个钻孔于模型中心2×3分布，钻孔中心间距为30mm，距离左右边界为10mm，距离上下边界为20mm。

  方案5 Abaqus源文件点此处下载。

图3.29 方案5（钻孔2×3）试件截面草图

图3.29 方案5（钻孔2×3）试件截面草图

  用Abaqus进行仿真，绘制的应力、应变、位移云图如下。

图3.30 方案5（钻孔2×3）试件应力云图（等轴视图）

图3.30 方案5（钻孔2×3）试件应力云图（等轴视图）

图3.31 方案5（钻孔2×3）试件应力云图（前视图）

图3.31 方案5（钻孔2×3）试件应力云图（前视图）

图3.32 方案5（钻孔2×3）试件应变云图（等轴视图）

图3.32 方案5（钻孔2×3）试件应变云图（等轴视图）

图3.33 方案5（钻孔2×3）试件应变云图（前视图）

图3.33 方案5（钻孔2×3）试件应变云图（前视图）

图3.34 方案5（钻孔2×3）试件位移云图（等轴视图）

图3.34 方案5（钻孔2×3）试件位移云图（等轴视图）

图3.35 方案5（钻孔2×3）试件位移云图（前视图）

图3.35 方案5（钻孔2×3）试件位移云图（前视图）

4 总结

  提取各方案上表面竖直方向的位移，并与无孔时的解析解进行比较，见表 4.1。

表 4.1 各方案上表面竖直方向的位移

方案轴向位移
无孔4.00×10−54.00\times10^{-5}
1x24.13×10−54.13\times10^{-5}
1x34.17×10−54.17\times10^{-5}
2x14.19×10−54.19\times10^{-5}
2x24.45×10−54.45\times10^{-5}
2x34.69×10−54.69\times10^{-5}

  由表 4.1 可以看出，钻孔会增大煤体在轴向压缩下的位移，且钻孔数量越多、位移越大。在同样 1MPa 压强下，位移越大意味着煤体刚度越低、承载能力越弱——这与钻孔卸压的工程目的是一致的：通过钻孔削弱煤体的整体强度，把高应力区让出去，降低冲击危险。

  按位移相对无孔的增幅排列各方案：

排布方案钻孔数轴向位移相对无孔的增幅
无孔004.00×10−54.00\times10^{-5}−-
1×2224.13×10−54.13\times10^{-5}3.2%3.2\%
1×3334.17×10−54.17\times10^{-5}4.2%4.2\%
2×1224.19×10−54.19\times10^{-5}4.7%4.7\%
2×2444.45×10−54.45\times10^{-5}11.2%11.2\%
2×3664.69×10−54.69\times10^{-5}17.2%17.2\%

  规律有两条。其一，钻孔数量是主因：位移增幅基本随孔数单调上升（2 孔约 3∼5%3\sim5\%，4 孔 11.2%11.2\%，6 孔 17.2%17.2\%）。其二，相同孔数下排布方式也有影响：同为 2 孔，2×1 排布（两孔横向并列）的削弱效果（4.7%4.7\%）大于 1×2 排布（两孔纵向串联，3.2%3.2\%）。这说明在钻孔总数相同的前提下，把钻孔布置成横向多列比纵向多行的卸压效果更好。

  需要说明两点。一是表中位移为绝对值，Abaqus 中受压位移的原始输出为负值，本文统一取绝对值比较，符号不影响结论。二是本模型采用弹性本构，只反映刚度变化，不能给出煤体的峰值强度与塑性区演化；若要评价真实卸压效果，还需引入塑性或损伤本构，并考虑侧向应力的影响。

]]> https://primerusse.top/2026/01/16/202601160000/ 2026-01-15T16:00:00.000Z 钻孔排布对煤体强度影响的数值模拟。 Abaqus 模拟钻孔排布对煤体强度的影响 2026-01-15T16:00:00.000Z Primerusse 1 问题描述

  如下图所示的框架结构，其顶部梁跨中受集中力作用，用有限元方法分析该结构的应力、应变及位移。结构中各个截面的参数都为：E=3.0×1011PaE=3.0\times 10^{11}Pa，I=6.5×10−7m4I=6.5\times 10^{-7}m^4，A=6.8×10−4m2A=6.8\times 10^{-4}m^2。尝试改变各种不同的边界条件及载荷施加位置，进行相应的有限元分析，并对各种工况进行对比分析（至少选择2种不同的工况）。

图1.1 框架结构示意图

图1.1 框架结构示意图（A、B 为固定支座，C、D 为刚接节点，E 为载荷施加位置）

  本文中使用的Abaqus版本是2025。

2 Abaqus有限元模型与计算结果分析

  根据已知数据，假设梁截面为矩形。可以算出梁截面为 0.00635m×0.10710m0.00635m\times 0.10710m——该尺寸与题给的 II、AA 自洽（按 I=bh3/12I=bh^3/12 与 A=bhA=bh 反算，误差均在 0.01% 以内）。

  本文对比两种工况：中间载荷（P 作用于跨中 E 点）与偏置载荷（P 偏离跨中）。每种工况给出模型、应力与位移三张结果图。

2.1 中间载荷

  中间载荷Abaqus源文件点此处下载。

图2.1 框架结构有限元分析模型（中间载荷）

图2.1 框架结构有限元分析模型（中间载荷）

图2.2 框架结构应力云图（中间载荷）

图2.2 框架结构应力云图（中间载荷，Mises 应力峰值 3.362×10⁹ Pa）

图2.3 框架结构位移云图（中间载荷）

图2.3 框架结构位移云图（中间载荷，最大位移 4.422×10⁻¹ m）

2.2 偏置载荷

  偏置载荷Abaqus源文件点此处下载。

图2.4 框架结构有限元分析模型（偏置载荷）

图2.4 框架结构有限元分析模型（偏置载荷）

图2.5 框架结构应力云图（偏置载荷）

图2.5 框架结构应力云图（偏置载荷，Mises 应力峰值 2.498×10⁹ Pa）

图2.6 框架结构位移云图（偏置载荷）

图2.6 框架结构位移云图（偏置载荷，最大位移 3.038×10⁻¹ m）

3 结果对比与讨论

  两种工况的计算结果如下表。

工况Mises 应力峰值最大位移
中间载荷（E 点）3.362×109Pa3.362\times 10^{9}Pa4.422×10−1m4.422\times 10^{-1}m
偏置载荷2.498×109Pa2.498\times 10^{9}Pa3.038×10−1m3.038\times 10^{-1}m

  由结果可见，载荷施加位置显著改变了结构的力学响应：应力峰值相差约 35%，最大位移相差约 46%。载荷偏离跨中后，两侧立柱分担的弯矩不再对称，靠近载荷一侧的柱与梁柱节点承受更大内力，因而应力分布与变形形态都随之改变。

  两种工况下峰值应力都出现在顶部横梁与立柱的刚接节点处（靠载荷一侧），而非载荷施加点正下方。以中间载荷工况为例，红色高应力区集中在横梁右端的节点附近；偏置载荷工况同样如此。

  这与框架的受力特点有关。竖向载荷在横梁内产生弯矩，梁端弯矩需通过刚接节点传递给立柱；节点处既要传递梁端弯矩，又要承受立柱的柱端弯矩，两个方向的弯矩叠加，使该处成为全结构弯矩最大、应力最高的位置。而载荷作用点处虽有集中力，但该处截面承受的主要是局部压力，量值远低于节点处的弯曲应力。

  需要说明的是，本题仅对比了载荷位置的变化，未改变边界条件（A、B 始终保持固定支座）。若进一步固定支座改为铰支，结构将成为机构或改变内力分布形式，是另一个值得单独分析的方向。

]]> https://primerusse.top/2026/01/04/202601040400/ 2026-01-03T20:00:00.000Z 载荷位置如何改变框架的应力场与位移场。 Abaqus 载荷施加位置对框架结构应力与位移的影响 2026-01-03T20:00:00.000Z Primerusse 1 圣维南原理

  圣维南原理（Saint-Venant’s Principle）由法国力学家圣维南于 1855 年提出：作用在弹性体上一小块区域内的荷载，在离荷载作用区稍远处引起的应力，基本上只取决于荷载的合力与合力矩，而与荷载的具体分布形式无关；分布形式只影响荷载区附近的应力。

  这条原理至今没有严格的数学证明，主要依赖工程实践与实验验证。一个自然的疑问是：“稍远”到底要多远？ 本文用两组静力等效的载荷（集中力与均布载荷，合力均为 1000N）作用于同一悬臂梁，提取中轴线上各应力分量沿板长的分布并逐点对比，用差值随距离的衰减来回答这个问题。

  本文中使用的Abaqus版本是2025。

2 Abaqus模型构建与应力云图

2.1 集中力1000N

  集中力Abaqus源文件点此处下载。

图2.1 悬臂梁有限元分析模型（自由端受集中力1000N）

图2.1 悬臂梁有限元分析模型（自由端受集中力1000N）

图2.2 悬臂梁固定端边界条件（自由端受集中力1000N）

图2.2 悬臂梁固定端边界条件（自由端受集中力1000N）

图2.3 悬臂梁自由端载荷条件（自由端受集中力1000N）

图2.3 悬臂梁自由端载荷条件（自由端受集中力1000N）

图2.4 悬臂梁应力云图（自由端受集中力1000N）

图2.4 悬臂梁应力云图（自由端受集中力1000N）

2.2 均布载荷10N/m2

  均布载荷Abaqus源文件点此处下载。

图2.5 悬臂梁有限元分析模型（自由端受均布载荷10N/m^2)

图2.5 悬臂梁有限元分析模型（自由端受均布载荷10N/m2）

图2.6 悬臂梁固定端边界条件（自由端受均布载荷10N/m^2>）</center>

图2.6 悬臂梁固定端边界条件（自由端受均布载荷10N/m2>）

图2.7 悬臂梁自由端载荷条件（自由端受均布载荷10N/m^2）

图2.7 悬臂梁自由端载荷条件（自由端受均布载荷10N/m2）

图2.8 悬臂梁应力云图（自由端受均布载荷10N/m^2）

图2.8 悬臂梁应力云图（自由端受均布载荷10N/m2）

2.3 两种状况下中轴线应力比较

  沿板长方向（X 从 -50 到 50）建立应力提取路径，逐点读取两种荷载作用下的应力分量并作差，如下表（单位：Pa）。

表2.1 悬臂梁在两种不同荷载作用下的中轴线S11应力比较

X集中载荷S11均布载荷S11差值
−50-508.876238.876238.876238.8762300
−45-4510.495710.495710.495710.495700
−40-4010.087210.087210.087210.087200
−35-3510.002210.002210.002210.002200
−30-309.999279.999279.999279.9992700
−25-259.999919.999919.999919.9999100
−20-201010101000
−15-151010101000
−10-101010101000
−5-51010101000
001010101000
551010101000
10101010101000
15151010101000
202010.000110.000110100.00010.0001
25259.999729.999721010−0.00028-0.00028
30309.99119.99111010−0.0089-0.0089
35359.95749.95741010−0.0426-0.0426
404010.563910.563910100.56390.5639
454522.382822.3828101012.382812.3828
50501948.331948.3310101938.331938.33

表2.2 悬臂梁在两种不同荷载作用下的中轴线S22应力比较

X集中载荷S22均布载荷S22差值
−50-503.4493.4493.4493.44900
−45-450.1815410.1815410.1815410.18154100
−40-40−0.0448052-0.0448052−0.0448052-0.044805200
−35-35−0.00582249-0.00582249−0.00582249-0.0058224900
−30-30−4.07153×10−5-4.07153\times10^{-5}−4.07153×10−5-4.07153\times10^{-5}00
−25-255.82346×10−55.82346\times10^{-5}5.82345×10−55.82345\times10^{-5}1×10−101\times10^{-10}
−20-205.61251×10−65.61251\times10^{-6}5.61246×10−65.61246\times10^{-6}5×10−115\times10^{-11}
−15-15−1.2148×10−7-1.2148\times10^{-7}−1.21758×10−7-1.21758\times10^{-7}2.78×10−102.78\times10^{-10}
−10-10−6.97173×10−8-6.97173\times10^{-8}−7.12579×10−8-7.12579\times10^{-8}1.5406×10−91.5406\times10^{-9}
−5-52.3356×10−92.3356\times10^{-9}−5.21618×10−9-5.21618\times10^{-9}7.55178×10−97.55178\times10^{-9}
002.81916×10−82.81916\times10^{-8}2.64232×10−102.64232\times10^{-10}2.79274×10−82.79274\times10^{-8}
55−1.30203×10−8-1.30203\times10^{-8}7.4926×10−117.4926\times10^{-11}−1.30952×10−8-1.30952\times10^{-8}
1010−1.53791×10−6-1.53791\times10^{-6}3.36547×10−123.36547\times10^{-12}−1.53791×10−6-1.53791\times10^{-6}
1515−0.000014944-0.000014944−4.097×10−13-4.097\times10^{-13}−0.000014944-0.000014944
2020−5.98787×10−5-5.98787\times10^{-5}−7.79377×10−14-7.79377\times10^{-14}−5.98787×10−5-5.98787\times10^{-5}
25250.0001401980.0001401982.31509×10−132.31509\times10^{-13}0.0001401980.000140198
30300.001139830.001139833.13638×10−153.13638\times10^{-15}0.001139830.00113983
3535−0.0399905-0.03999053.80251×10−153.80251\times10^{-15}−0.0399905-0.0399905
4040−0.672806-0.6728067.52454×10−147.52454\times10^{-14}−0.672806-0.672806
4545−4.43144-4.43144−8.54317×10−14-8.54317\times10^{-14}−4.43144-4.43144
5050682.577682.577−4.13836×10−13-4.13836\times10^{-13}682.577682.577

表2.3 悬臂梁在两种不同荷载作用下的中轴线S33应力比较

X集中载荷S33均布载荷S33差值
−50-503.4493.4493.4493.44900
−45-450.1815410.1815410.1815410.18154100
−40-40−0.0448052-0.0448052−0.0448052-0.044805200
−35-35−0.00582249-0.00582249−0.00582249-0.0058224900
−30-30−4.07153×10−5-4.07153\times10^{-5}−4.07153×10−5-4.07153\times10^{-5}00
−25-255.82346×10−55.82346\times10^{-5}5.82345×10−55.82345\times10^{-5}1×10−101\times10^{-10}
−20-205.61251×10−65.61251\times10^{-6}5.61246×10−65.61246\times10^{-6}5×10−115\times10^{-11}
−15-15−1.2148×10−7-1.2148\times10^{-7}−1.21758×10−7-1.21758\times10^{-7}2.78×10−102.78\times10^{-10}
−10-10−6.97174×10−8-6.97174\times10^{-8}−7.1258×10−8-7.1258\times10^{-8}1.5406×10−91.5406\times10^{-9}
−5-52.33567×10−92.33567\times10^{-9}−5.21611×10−9-5.21611\times10^{-9}7.55178×10−97.55178\times10^{-9}
002.81916×10−82.81916\times10^{-8}2.6429×10−102.6429\times10^{-10}2.79273×10−82.79273\times10^{-8}
55−1.30203×10−8-1.30203\times10^{-8}7.49479×10−117.49479\times10^{-11}−1.30952×10−8-1.30952\times10^{-8}
1010−1.53791×10−6-1.53791\times10^{-6}3.43481×10−123.43481\times10^{-12}−1.53791×10−6-1.53791\times10^{-6}
1515−0.000014944-0.000014944−4.53082×10−13-4.53082\times10^{-13}−0.000014944-0.000014944
2020−5.98787×10−5-5.98787\times10^{-5}−8.99281×10−14-8.99281\times10^{-14}−5.98787×10−5-5.98787\times10^{-5}
25250.0001401980.0001401988.67084×10−148.67084\times10^{-14}0.0001401980.000140198
30300.001139830.001139835.70655×10−145.70655\times10^{-14}0.001139830.00113983
3535−0.0399905-0.03999052.22045×10−152.22045\times10^{-15}−0.0399905-0.0399905
4040−0.672806-0.672806−1.23457×10−13-1.23457\times10^{-13}−0.672806-0.672806
4545−4.43144-4.431441.55764×10−131.55764\times10^{-13}−4.43144-4.43144
5050682.577682.577−3.19744×10−13-3.19744\times10^{-13}682.577682.577

表2.4 悬臂梁在两种不同荷载作用下的中轴线S12应力比较

X集中载荷S12均布载荷S12差值
−50-50000000
−45-45000000
−40-40000000
−35-35000000
−30-30000000
−25-25−8.52651×10−14-8.52651\times10^{-14}−2.98428×10−13-2.98428\times10^{-13}2.13163×10−132.13163\times10^{-13}
−20-20−1.50768×10−13-1.50768\times10^{-13}−1.4827×10−13-1.4827\times10^{-13}−2.498×10−15-2.498\times10^{-15}
−15-15−1.10134×10−13-1.10134\times10^{-13}−1.29674×10−13-1.29674\times10^{-13}1.954×10−141.954\times10^{-14}
−10-10−1.82521×10−13-1.82521\times10^{-13}−1.87406×10−13-1.87406\times10^{-13}4.885×10−154.885\times10^{-15}
−5-5−1.49214×10−13-1.49214\times10^{-13}−2.09388×10−13-2.09388\times10^{-13}6.0174×10−146.0174\times10^{-14}
00−1.42109×10−13-1.42109\times10^{-13}−4.52416×10−14-4.52416\times10^{-14}−9.68674×10−14-9.68674\times10^{-14}
55−1.7053×10−13-1.7053\times10^{-13}4.47489×10−144.47489\times10^{-14}−2.15279×10−13-2.15279\times10^{-13}
101000−1.71286×10−13-1.71286\times10^{-13}1.71286×10−131.71286\times10^{-13}
151500−1.61523×10−13-1.61523\times10^{-13}1.61523×10−131.61523\times10^{-13}
202000−2.76914×10−13-2.76914\times10^{-13}2.76914×10−132.76914\times10^{-13}
252500−9.90686×10−14-9.90686\times10^{-14}9.90686×10−149.90686\times10^{-14}
3030001.018×10−131.018\times10^{-13}−1.018×10−13-1.018\times10^{-13}
3535006.41111×10−146.41111\times10^{-14}−6.41111×10−14-6.41111\times10^{-14}
4040003.89831×10−133.89831\times10^{-13}−3.89831×10−13-3.89831\times10^{-13}
454500−5.50768×10−15-5.50768\times10^{-15}5.50768×10−155.50768\times10^{-15}
5050004.35473×10−144.35473\times10^{-14}−4.35473×10−14-4.35473\times10^{-14}

表2.5 悬臂梁在两种不同荷载作用下的中轴线S13应力比较

X集中载荷S13均布载荷S13差值
−50-50000000
−45-45000000
−40-40000000
−35-35000000
−30-30−2.27374×10−13-2.27374\times10^{-13}−2.27374×10−13-2.27374\times10^{-13}00
−25-25−2.27374×10−13-2.27374\times10^{-13}−2.41585×10−13-2.41585\times10^{-13}1.4211×10−141.4211\times10^{-14}
−20-20−2.93321×10−13-2.93321\times10^{-13}−2.921×10−13-2.921\times10^{-13}−1.221×10−15-1.221\times10^{-15}
−15-15−2.64677×10−13-2.64677\times10^{-13}−1.98952×10−13-1.98952\times10^{-13}−6.5725×10−14-6.5725\times10^{-14}
−10-10−2.31815×10−13-2.31815\times10^{-13}−1.63425×10−13-1.63425\times10^{-13}−6.839×10−14-6.839\times10^{-14}
−5-5−3.05533×10−13-3.05533\times10^{-13}−1.72307×10−13-1.72307\times10^{-13}−1.33226×10−13-1.33226\times10^{-13}
00−4.40536×10−13-4.40536\times10^{-13}−3.31013×10−13-3.31013\times10^{-13}−1.09523×10−13-1.09523\times10^{-13}
55−3.12639×10−13-3.12639\times10^{-13}−2.22298×10−13-2.22298\times10^{-13}−9.0341×10−14-9.0341\times10^{-14}
101000−4.6596×10−14-4.6596\times10^{-14}4.6596×10−144.6596\times10^{-14}
151500−6.4631×10−14-6.4631\times10^{-14}6.4631×10−146.4631\times10^{-14}
2020005.40989×10−145.40989\times10^{-14}−5.40989×10−14-5.40989\times10^{-14}
2525001.69664×10−131.69664\times10^{-13}−1.69664×10−13-1.69664\times10^{-13}
303000−3.03531×10−13-3.03531\times10^{-13}3.03531×10−133.03531\times10^{-13}
353500−2.91012×10−13-2.91012\times10^{-13}2.91012×10−132.91012\times10^{-13}
404000−1.0803×10−13-1.0803\times10^{-13}1.0803×10−131.0803\times10^{-13}
454500−4.29756×10−13-4.29756\times10^{-13}4.29756×10−134.29756\times10^{-13}
5050001.35333×10−131.35333\times10^{-13}−1.35333×10−13-1.35333\times10^{-13}

表2.6 悬臂梁在两种不同荷载作用下的中轴线S23应力比较

X集中载荷S23均布载荷S23差值
−50-50000000
−45-45000000
−40-40000000
−35-352.84217×10−142.84217\times10^{-14}002.84217×10−142.84217\times10^{-14}
−30-302.84217×10−142.84217\times10^{-14}−1.42109×10−14-1.42109\times10^{-14}4.26326×10−144.26326\times10^{-14}
−25-252.84217×10−142.84217\times10^{-14}3.37508×10−143.37508\times10^{-14}−5.3291×10−15-5.3291\times10^{-15}
−20-201.90958×10−141.90958\times10^{-14}2.54241×10−142.54241\times10^{-14}−6.3283×10−15-6.3283\times10^{-15}
−15-15−1.37113×10−14-1.37113\times10^{-14}−1.55986×10−14-1.55986\times10^{-14}1.8873×10−151.8873\times10^{-15}
−10-10−5.03139×10−14-5.03139\times10^{-14}−5.52319×10−14-5.52319\times10^{-14}4.918×10−154.918\times10^{-15}
−5-51.24206×10−141.24206\times10^{-14}−2.21513×10−15-2.21513\times10^{-15}1.46357×10−141.46357\times10^{-14}
003.90799×10−143.90799\times10^{-14}5.78159×10−145.78159\times10^{-14}−1.8736×10−14-1.8736\times10^{-14}
557.10543×10−157.10543\times10^{-15}−1.99846×10−15-1.99846\times10^{-15}9.10389×10−159.10389\times10^{-15}
10105.68434×10−145.68434\times10^{-14}6.66726×10−146.66726\times10^{-14}−9.8292×10−15-9.8292\times10^{-15}
1515003.93328×10−143.93328\times10^{-14}−3.93328×10−14-3.93328\times10^{-14}
2020002.20134×10−142.20134\times10^{-14}−2.20134×10−14-2.20134\times10^{-14}
2525008.48766×10−148.48766\times10^{-14}−8.48766×10−14-8.48766\times10^{-14}
3030002.39167×10−142.39167\times10^{-14}−2.39167×10−14-2.39167\times10^{-14}
3535001.18696×10−141.18696\times10^{-14}−1.18696×10−14-1.18696\times10^{-14}
4040005.65762×10−145.65762\times10^{-14}−5.65762×10−14-5.65762\times10^{-14}
4545007.4142×10−147.4142\times10^{-14}−7.4142×10−14-7.4142\times10^{-14}
5050003.31265×10−133.31265\times10^{-13}−3.31265×10−13-3.31265\times10^{-13}

  在直角坐标系中，绘制图像。

图2.9 悬臂梁在两种不同荷载作用下的中轴线S11应力曲线对比

图2.9 悬臂梁在两种不同荷载作用下的中轴线S11应力曲线对比

图2.10 悬臂梁在两种不同荷载作用下的中轴线S22应力曲线对比

图2.10 悬臂梁在两种不同荷载作用下的中轴线S22应力曲线对比

图2.11 悬臂梁在两种不同荷载作用下的中轴线S33应力曲线对比

图2.11 悬臂梁在两种不同荷载作用下的中轴线S33应力曲线对比

图2.12 悬臂梁在两种不同荷载作用下的中轴线S12应力曲线对比

图2.12 悬臂梁在两种不同荷载作用下的中轴线S12应力曲线对比

图2.13 悬臂梁在两种不同荷载作用下的中轴线S13应力曲线对比

图2.13 悬臂梁在两种不同荷载作用下的中轴线S13应力曲线对比

图2.14 悬臂梁在两种不同荷载作用下的中轴线S23应力曲线对比

图2.14 悬臂梁在两种不同荷载作用下的中轴线S23应力曲线对比

  由图可见：在远离载荷作用区的一段范围内，两种载荷的应力曲线完全重合；越靠近载荷施加端，两条曲线才逐渐分离，且分离程度随距离减小而急剧增大。这与圣维南原理的预期一致。

3 分析与总结

  本次对比沿中轴线提取了 S11S11（轴向）、S22S22（竖向）、S33S33（厚度方向）、S12S12、S13S13、S23S23 六个应力分量，逐点作差。其中起决定作用的是 S11S11，S12S12、S13S13、S23S23 三个剪应力分量在两种工况下全为 0，S22S22 与 S33S33 数值相同（见下文说明）。下面以 S11S11 为主线分析。

  在中轴线的 X=−50X=-50 至 X=20X=20 区间（远离载荷作用区），集中力（1000N1000N）与均布载荷（10N/m210N/m^2）作用下的 S11S11 完全一致，差值为 0——该段应力只由合力决定，与分布形式无关。

  在 X=25X=25 至 X=50X=50 区间（靠近载荷作用区），两者开始分离且分离迅速加剧：X=25X=25 处差值仅约 2.8×10−4Pa2.8\times10^{-4}Pa，到 X=50X=50 处已达 1.94×103Pa1.94\times10^{3}Pa，增大约 7 个数量级。载荷作用点上，集中力对应的 S11S11 为 1948.33Pa1948.33Pa，均布载荷仅为 10Pa10Pa——相差约 195 倍。原因很直接：集中力把荷载压在一点上，该点附近应力急剧升高；均布载荷把同样的合力摊在一个区域上，应力平缓得多。

  由此可以给出本题的定量回答。取样路径全长 100 个单位（XX 从 −50-50 到 5050，−50-50 端为固定端，5050 端为加载端），按受载荷分布形式影响的程度可分为三段：

区段位置范围占全长两种载荷的应力
无差别区X=−50X=-50 至 X=20X=2070%70\%完全一致，差值恒为 00
过渡区X=20X=20 至 X=25X=255%5\%开始出现极微小差异（约 10−4Pa10^{-4}Pa 量级）
有明显差别区X=25X=25 至 X=50X=5025%25\%差异迅速增大，至加载端达 1.94×103Pa1.94\times10^{3}Pa

  也就是说：沿梁长从固定端起算，前 70% 的长度内，两种静力等效载荷引起的应力完全相同，载荷具体怎么分布毫无影响；再往加载端走 5% 进入过渡；最后 25% 的区段内分布形式的影响才显现，并且越靠近加载点越剧烈。这就是“稍远”在本问题中的具体尺度——约合全长的 70%。

  各分量的完整数据见第 2 章的表 2.1～表 2.6。此处补充两点说明。其一，表 2.1 中 X=−50X=-50 至 X=−5X=-5 段的 S11S11 并非恒定（8.88 → 10.50 → 10.00 …），这是固定端约束效应——−50-50 端为固支端，约束使该处应力偏离纯弯曲的均匀值，与载荷分布形式无关，两种工况在这一段仍完全一致。其二，表 2.2（S22S22）与表 2.3（S33S33）的数值逐点相同，这与本文所用二维平面模型有关，S33S33 在平面应力假设下不独立；若需考察厚度方向应力，应改用三维实体模型。

]]> https://primerusse.top/2026/01/04/202601040300/ 2026-01-03T19:00:00.000Z 数值模拟检验圣维南原理的适用边界。 Abaqus 验证圣维南原理的适用边界 2026-01-03T19:00:00.000Z Primerusse 1 横向均匀拉伸矩形带孔薄板问题

  如下图所示，一个厚度均匀的矩形薄板，左右两边受均匀拉伸载荷作用。已知薄板尺寸为：长 a=1ma=1m，宽 b=0.6mb=0.6m，厚 t=0.01mt=0.01m，在薄板中心位置挖掉一个半径为 r=0.1mr=0.1m 的圆孔。薄板左右两边均受 q=100MPaq=100MPa 的均匀载荷作用。薄板的弹性模量 E=200GPaE=200GPa，泊松比 μ=0.3\mu=0.3，忽略自重。试使用不同的单元类型及不同的单元数量（至少选择 33 组不同的情况）对薄板进行有限元分析（应力、应变及位移等），并与解析解对比计算精度。

  本文中使用的Abaqus版本是2025。

图1 矩形薄板示意图

图1 矩形薄板示意图

2 Abaqus模型构建

  Abaqus源文件点此处下载。

图2.1 带孔矩形薄板力学模型

图2.1 带孔矩形薄板力学模型

图2.2 带孔矩形薄板右表面载荷

图2.2 带孔矩形薄板右表面载荷

图2.3 带孔矩形薄板左表面载荷

图2.3 带孔矩形薄板左表面载荷

图2.4 带孔矩形薄板右表面边界条件

图2.4 带孔矩形薄板右表面边界条件

图2.5 带孔矩形薄板左表面边界条件

图2.5 带孔矩形薄板左表面边界条件

3 网格划分与数值模拟云图

  共计算三组：六面体网格（全局尺寸 0.05）、四面体网格（全局尺寸 0.05）、四面体网格（全局尺寸 0.005）。每组给出网格划分与应力、应变、位移云图。

3.1 六面体网格，全局尺寸0.05

图3.1 带孔矩形薄板六面体网格划分（全局尺寸0.05）

图3.1 带孔矩形薄板六面体网格划分（全局尺寸0.05）

图3.2 带孔矩形薄板应变云图（六面体网格，全局尺寸0.05）

图3.2 带孔矩形薄板应变云图（六面体网格，全局尺寸0.05）

图3.3 带孔矩形薄板应力云图（六面体网格，全局尺寸0.05）

图3.3 带孔矩形薄板应力云图（六面体网格，全局尺寸0.05）

图3.4 带孔矩形薄板位移云图（U1方向，六面体网格，全局尺寸0.05）

图3.4 带孔矩形薄板位移云图（U1方向，六面体网格，全局尺寸0.05）

图3.5 带孔矩形薄板位移云图（U2方向，六面体网格，全局尺寸0.05）

图3.5 带孔矩形薄板位移云图（U2方向，六面体网格，全局尺寸0.05）

图3.6 带孔矩形薄板位移云图（U3方向，六面体网格，全局尺寸0.05）

图3.6 带孔矩形薄板位移云图（U3方向，六面体网格，全局尺寸0.05）

3.2 四面体网格，全局尺寸0.05

图3.7 带孔矩形薄板四面体网格划分（全局尺寸0.05）

图3.7 带孔矩形薄板四面体网格划分（全局尺寸0.05）

图3.8 带孔矩形薄板应变云图（四面体网格，全局尺寸0.05）

图3.8 带孔矩形薄板应变云图（四面体网格，全局尺寸0.05）

图3.9 带孔矩形薄板应力云图（四面体网格，全局尺寸0.05）

图3.9 带孔矩形薄板应力云图（四面体网格，全局尺寸0.05）

图3.10 带孔矩形薄板位移云图（U1方向，四面体网格，全局尺寸0.05）

图3.10 带孔矩形薄板位移云图（U1方向，四面体网格，全局尺寸0.05）

图3.11 带孔矩形薄板位移云图（U2方向，四面体网格，全局尺寸0.05）

图3.11 带孔矩形薄板位移云图（U2方向，四面体网格，全局尺寸0.05）

图3.12 带孔矩形薄板位移云图（U3方向，四面体网格，全局尺寸0.05）

图3.12 带孔矩形薄板位移云图（U3方向，四面体网格，全局尺寸0.05）

3.3 四面体网格，全局尺寸0.005

图3.13 带孔矩形薄板四面体网格划分（全局尺寸0.005）

图3.13 带孔矩形薄板四面体网格划分（全局尺寸0.005）

图3.14 带孔矩形薄板应变云图（四面体网格，全局尺寸0.005）

图3.14 带孔矩形薄板应变云图（四面体网格，全局尺寸0.005）

图3.15 带孔矩形薄板应力云图（四面体网格，全局尺寸0.005）

图3.15 带孔矩形薄板应力云图（四面体网格，全局尺寸0.005）

图3.16 带孔矩形薄板位移云图（U1方向，四面体网格，全局尺寸0.005）

图3.16 带孔矩形薄板位移云图（U1方向，四面体网格，全局尺寸0.005）

图3.17 带孔矩形薄板位移云图（U2方向，四面体网格，全局尺寸0.005）

图3.17 带孔矩形薄板位移云图（U2方向，四面体网格，全局尺寸0.005）

图3.18 带孔矩形薄板位移云图（U3方向，四面体网格，全局尺寸0.005）

图3.18 带孔矩形薄板位移云图（U3方向，四面体网格，全局尺寸0.005）

4 数值模拟结果与解析结果比较

  先进行理论计算。由基尔斯（Kirsch）解答可知 σr\sigma_r、σθ\sigma_\theta、τrθ\tau_{r\theta} 的表达式，其中 aa 为圆孔半径：

{σr=q2(1−a2r2)+q2(1−4a2r2+3a4r4)cos⁡2θσθ=q2(1+a2r2)−q2(1+3a4r4)cos⁡2θτrθ=−q2(1+2a2r2−3a4r4)sin⁡2θ\begin{aligned} \begin{cases} \sigma_r=\dfrac{q}{2}\left(1-\dfrac{a^2}{r^2}\right)+\dfrac{q}{2}\left(1-\dfrac{4a^2}{r^2}+\dfrac{3a^4}{r^4}\right)\cos2\theta\\ \sigma_\theta=\dfrac{q}{2}\left(1+\dfrac{a^2}{r^2}\right)-\dfrac{q}{2}\left(1+\dfrac{3a^4}{r^4}\right)\cos2\theta\\ \tau_{r\theta}=-\dfrac{q}{2}\left(1+\dfrac{2a^2}{r^2}-\dfrac{3a^4}{r^4}\right)\sin2\theta \end{cases}\end{aligned}

  孔边应力集中点取 r=ar=a、θ=π2\theta=\dfrac{\pi}{2}、q=100MPaq=100MPa，代入得：

{σr=0σθ=3q=300MPaτrθ=0\begin{aligned} \begin{cases} \sigma_r=0\\ \sigma_\theta=3q=300MPa\\ \tau_{r\theta}=0 \end{cases}\end{aligned}

  该点处于与拉伸方向垂直的位置，化到直角坐标系即：

{σx=300MPaσy=0τxy=0\begin{aligned} \begin{cases} \sigma_x=300MPa\\ \sigma_y=0\\ \tau_{xy}=0 \end{cases}\end{aligned}

  与第3章结果进行比较，见下表。

表4.1 带孔矩形薄板圆孔应力集中点数值模拟与理论解析结果比较（单位：MPa）

项目σx\sigma_x 数值σx\sigma_x 绝对误差σy\sigma_y 数值σy\sigma_y 绝对误差τxy\tau_{xy} 数值τxy\tau_{xy} 绝对误差
理论计算300300−-00−-00−-
六面体网格（0.05）277.98277.98−22.02-22.0222.664422.664422.664422.664412.053512.053512.053512.0535
四面体网格（0.05）325.81325.8125.8125.8124.056424.056424.056424.056452.200352.200352.200352.2003
四面体网格（0.005）355.212355.21255.21255.2120.3388580.3388580.3388580.3388584.640434.640434.640434.64043

5 总结与讨论

  本次以带圆孔矩形薄板为对象，用 Abaqus 计算三组不同网格，并与基尔斯解比较。结果汇总如下表。

网格方案σx/MPa\sigma_x/MPa相对误差σy/MPa\sigma_y/MPaτxy/MPa\tau_{xy}/MPa
理论（基尔斯解）300300−-0000
六面体 0.05277.98277.987.34%7.34\%22.664422.664412.053512.0535
四面体 0.05325.81325.818.60%8.60\%24.056424.056452.200352.2003
四面体 0.005355.212355.21218.40%18.40\%0.3388580.3388584.640434.64043

  网格类型的影响：在相同网格尺寸（0.05m0.05m）下，六面体网格的 σx\sigma_x 相对误差为 7.34%7.34\%，低于四面体网格的 8.60%8.60\%；τxy\tau_{xy} 更是从 52.20MPa52.20MPa 降到 12.05MPa12.05MPa（理论值为 0）。这与两类单元的固有性质一致——六面体单元形函数插值精度更高，且在规则几何上更容易生成形态良好的单元。

  网格尺寸的影响：把四面体网格从 0.05m0.05m 细化到 0.005m0.005m（单元尺寸缩小到 1/10）后，三个分量的表现并不一致。σy\sigma_y 的误差由 24.06MPa24.06MPa 降到 0.34MPa0.34MPa，τxy\tau_{xy} 由 52.20MPa52.20MPa 降到 4.64MPa4.64MPa——两者都大幅改善。σx\sigma_x 则从 325.81MPa325.81MPa 升到 355.212MPa355.212MPa，相对误差由 8.60%8.60\% 变为 18.40%18.40\%。

  这三个分量的差异，恰好可以用同一个机制解释清楚。σy\sigma_y 与 τxy\tau_{xy} 的理论值都是 0，它们属于“孔边的非峰值分量”，本来就应该趋于 0；网格细化使单元内的应力变化减小，读数自然更贴近 0，所以误差大幅下降。σx\sigma_x 的理论值则是孔边峰值 300MPa300MPa——孔边是应力集中点，σx\sigma_x 从孔边的峰值向外迅速衰减，而有限元给出的是单元内的近似（本例还采用了 75% 的节点应力平均，进一步平滑了峰值）。单元越粗，单元覆盖的范围内应力落差越大，平均值就越低于真实峰值，因此粗网格低估 σx\sigma_x；网格细化后单元覆盖范围缩小，平均值趋近峰值，所以 σx\sigma_x 随细化升高。

  换句话说：σy\sigma_y、τxy\tau_{xy} 的读数向 0 靠拢，σx\sigma_x 的读数向 300MPa300MPa 的峰值方向抬升，两者的变化方向不同，但都是各自向真值收敛的正确表现。σx\sigma_x 升高不是错误，而正是细化在起作用。

  至于三组 σx\sigma_x 与理论值仍有差距（277.98277.98、325.81325.81、355.212MPa355.212MPa 对应 300MPa300MPa），原因是网格相对孔径仍不够细。本例单元尺寸 0.005m0.005m 与孔径 0.1m0.1m 之比为 1/201/20，而应力集中点的峰值需要远细于此的局部网格（通常要求孔边单元尺寸达到孔径的 1/501/50 甚至更小）才能准确捕捉；再叠加 75% 节点平均带来的平滑，读数与理论峰值存在百分之十几的差距属正常范围。若继续在孔边做局部加密，σx\sigma_x 会进一步趋近 300MPa300MPa 并趋于稳定，这是应力集中问题的标准收敛过程。因此本文结论是：对应力集中问题，网格细化会提升峰值应力的求解精度，但要求孔边局部单元尺寸远小于孔径，全局网格加密的代价高而收益有限。

  位移分布规律：由位移云图与数值输出可见，U1U1（水平）位移随网格细化轻微增大（六面体 0.05m0.05m 下约 2.1×10−3m2.1\times10^{-3}m，四面体 0.05m0.05m 下 2.3×10−3m2.3\times10^{-3}m，四面体 0.005m0.005m 下 2.6×10−3m2.6\times10^{-3}m），反映细化后对局部变形的捕捉更充分；U2U2（竖直）位移在三种方案下均在 1.5∼1.7×10−3m1.5\sim1.7\times10^{-3}m 之间，波动很小，说明它主要由整体受力特征决定；U3U3（厚度方向）位移在 10−6m10^{-6}m 量级，可忽略——这从数值上印证了把该问题按平面应力简化的合理性。

  关于左右不对称现象：计算中发现位移云图的形状左右对称，但数值并不左右对称，多组重复计算均如此。一种可能是两侧均布载荷的施加顺序（先右后左）引入了整体的刚体位移分量；若确实如此，可用“变形前孔心与变形后孔心的水平距离”作为修正量，从各点水平位移中扣除。这一点尚未做独立的验证实验（例如把载荷改为一次施加、或改用位移边界），因此这里只作为现象记录，不作为结论。

]]> https://primerusse.top/2026/01/04/202601040200/ 2026-01-03T18:00:00.000Z 拉伸带孔薄板：应力集中与网格精度对比。 Abaqus 带孔薄板拉伸：应力集中与网格精度 2026-01-03T18:00:00.000Z Primerusse 1 悬臂梁平面问题题目图1.1 悬臂梁示意图

图1.1 悬臂梁示意图

  已知：悬臂梁的材料参数为 E=190GPaE=190GPa，μ=0.25\mu=0.25，t=10cmt=10cm，ρ=0\rho=0。尺寸参数如图。

  要求：

  （1）单元数量从少到多自行选择 3 组计算对比结果（与解析解对比计算精度）。

  （2）采用三角形三结点单元（题目可以看做是平面应力问题），用程序计算求解。

  （3）对应选择的每一组单元数量形式，画出力学模型图（包括单元的划分、结点编码、等效结点荷载、位移约束等信息）。

  （4）写出输入数据和输出数据（位移、应力）。

  （5）画出如下图形式的变形网格图。

图1.2 变形网格示意图

图1.2 变形网格示意图

2 Abaqus有限元模拟

  **本文中使用的 Abaqus 版本是 2025。**Abaqus 源文件点此处下载。

  需要说明的是，本篇用 Abaqus 建模求解，网格为结构化四边形单元；题目第（2）条要求的三角形三结点单元由自编程序实现，见 Python 自编四结点等参单元求解悬臂梁。两篇互为对照：Abaqus 结果用作校核基准，自编程序结果用以检验程序正确性。

2.1 位移结果

图2.1 悬臂梁位移云图（U1，沿梁长方向）

图2.1 悬臂梁位移云图（U1，沿梁长方向）

  沿梁长方向的最大位移为 U1=1.331×10−3mU_1=1.331\times10^{-3}m，出现在自由端，方向指向受力一侧；固定端处位移为 0，边界条件施加正确。

图2.2 悬臂梁位移云图（U2，垂直梁长方向）

图2.2 悬臂梁位移云图（U2，垂直梁长方向）

  垂直方向位移 U2U_2 的极值为 −6.608×10−3m-6.608\times10^{-3}m，量级比 U1U_1 大约 5 倍——这正是悬臂梁以弯曲变形为主的特征。

2.2 应力结果

图2.3 悬臂梁应力云图（S11，轴向正应力）

图2.3 悬臂梁应力云图（S11，轴向正应力）

  S11S_{11} 自上表面 +1.425×108Pa+1.425\times10^{8}Pa 拉应力线性过渡到下表面 −5.387×107Pa-5.387\times10^{7}Pa 压应力，中性轴附近应力为 0，符合梁弯曲的正应力分布规律。拉压峰值不对称，是因为梁还存在轴向分量。

图2.4 悬臂梁应力云图（S12，切应力）

图2.4 悬臂梁应力云图（S12，切应力）

  S12S_{12} 峰值 4.949×106Pa4.949\times10^{6}Pa，比正应力小约 1 个数量级，说明该梁以弯曲正应力为主导，切应力的贡献次要。

3 小结

  Abaqus 计算结果给出了本问题的位移与应力分布特征：变形以弯曲为主（U2U_2 显著大于 U1U_1），正应力沿截面高度线性分布且中性轴处为零，切应力比正应力小一个数量级。这些结果与材料力学中悬臂梁的理论预期一致，可作为校核自编程序（Python 篇）的基准。

]]> https://primerusse.top/2026/01/04/202601040100/ 2026-01-03T17:00:00.000Z 悬臂梁平面问题的完整建模与分析流程。 Abaqus 悬臂梁平面问题有限元分析 2026-01-03T17:00:00.000Z Primerusse 1 悬臂梁平面问题题目图1.1 悬臂梁示意图

图1.1 悬臂梁示意图

  已知：悬臂梁的材料参数为E=190GPaE=190GPa，μ=0.25\mu=0.25，t=10cmt=10cm，ρ=0\rho=0。尺寸参数如图。

  要求：

  （1）单元数量从少到多自行选择3组计算对比结果（与解析解对比计算精度）。

  （2）采用三角形三结点单元（题目可以看做是平面应力问题），用程序计算求解。

  （3）对应选择的每一组单元数量形式，画出力学模型图（包括单元的划分、结点编码、等效结点荷载、位移约束等信息）。

  （4）写出输入数据和输出数据（位移、应力）。

  （5）画出如下图形式的变形网格图。

图1.2 变形网格示意图

图1.2 变形网格示意图

2 Python源程序

  **本文中使用的Python版本是3.14.3(64-bit)。**源程序已上传 GitHub：四结点四边形单元。

  两个程序（四结点四边形单元、三结点三角形单元）结构完全一致，都是标准的有限元流程：

段落作用
1 导入依赖库numpy 用于矩阵运算与线性方程组求解，matplotlib 用于绘制网格与云图
2 全局配置几何、材料、数值计算参数，以及基于这些参数推导的理论解
3 输入处理工具函数参数读取与校验
4 单元核心计算函数形函数、雅可比矩阵、BB 矩阵、单元刚度矩阵、应力计算
5 可视化函数绘制网格划分、节点与单元编号、等效节点荷载、位移约束、云图
6 主分析流程生成网格 → 组装总刚与荷载向量 → 施加边界条件 → 求解 → 提取位移与应力 → 误差分析
7 程序入口组织并调用上述流程

2.1 四结点四边形单元有限元Python程序

  源代码已上传github，详见链接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
"""
等截面悬臂梁平面应力有限元分析程序（四结点四边形单元版 v2.4.1）

核心功能：
1. 基于四节点四边形等参单元实现悬臂梁平面应力有限元全流程分析
2. 优化位移计算精度（自由端中点插值、高精度荷载积分）
3. 生成6张高清可视化图片
"""


# ===================== 1. 导入依赖库 =====================
import traceback
from typing import Tuple, Dict, Any

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from numpy.polynomial.legendre import leggauss
from scipy.interpolate import interp1d


# ===================== 2. 全局配置 =====================
# 绘图配置
matplotlib.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'PingFang SC']
matplotlib.rcParams['axes.unicode_minus'] = False
matplotlib.rcParams['figure.dpi'] = 120
matplotlib.rcParams['savefig.dpi'] = 300

# 几何参数（与理论解严格匹配）
BEAM_LENGTH = 5.0          # 梁总长 (m)
BEAM_HEIGHT = 1.0          # 梁截面高度 (m)
BEAM_THICKNESS = 0.1       # 梁厚度（平面应力）(m)

# 材料参数
ELASTIC_MODULUS = 190e9    # 弹性模量 (Pa)
POISSON_RATIO = 0.25       # 泊松比
APPLIED_SHEAR_STRESS = 10e6  # 顶部剪应力 (Pa)

# 理论解（基于上述参数推导）
THEORY_DISP_X = 0.00131578947368  # 自由端水平位移 (m)
THEORY_DISP_Y = -0.0130921052632  # 自由端竖向位移 (m)

# 数值计算参数
GAUSS_ORDER = 2            # 2×2高斯积分（4节点单元最优）
TINY_VALUE = 1e-15         # 数值稳定性极小值
FLOAT_TYPE = np.float64    # 双精度浮点类型
DISP_SCALE_FACTOR = 10     # 位移放大因子


# ===================== 3. 输入处理工具函数 =====================
def get_valid_integer_input(prompt: str, min_value: int = 2) -> int:
    """
    获取用户输入的有效正整数，包含输入合法性验证
    
    Args:
        prompt: 输入提示文本
        min_value: 输入最小值（默认2，保证至少1个单元）
    
    Returns:
        验证通过的正整数
    """
    while True:
        try:
            user_input = int(input(prompt))
            if user_input >= min_value:
                return user_input
            print(f"错误：数值必须≥{min_value}，请重新输入")
        except ValueError:
            print("错误：请输入有效正整数（如5、10、20）")


# ===================== 4. 四边形单元核心计算函数 =====================
def quad4_shape_functions(s: float, t: float) -> np.ndarray:
    """计算4节点四边形等参单元形函数值（自然坐标[-1,1]）"""
    n1 = (1 - s) * (1 - t) / 4.0
    n2 = (1 + s) * (1 - t) / 4.0
    n3 = (1 + s) * (1 + t) / 4.0
    n4 = (1 - s) * (1 + t) / 4.0
    return np.array([n1, n2, n3, n4], dtype=FLOAT_TYPE)

def quad4_shape_derivatives(s: float, t: float) -> Tuple[np.ndarray, np.ndarray]:
    """计算4节点四边形单元形函数对自然坐标的偏导数"""
    dN_ds = np.array([
        -(1 - t)/4.0, (1 - t)/4.0,
        (1 + t)/4.0, -(1 + t)/4.0
    ], dtype=FLOAT_TYPE)
    
    dN_dt = np.array([
        -(1 - s)/4.0, -(1 + s)/4.0,
        (1 + s)/4.0, (1 - s)/4.0
    ], dtype=FLOAT_TYPE)
    
    return dN_ds, dN_dt

def calculate_jacobian(
    dN_ds: np.ndarray,
    dN_dt: np.ndarray,
    elem_x: np.ndarray,
    elem_y: np.ndarray
) -> Tuple[np.ndarray, float, np.ndarray]:
    """计算雅可比矩阵、行列式及逆矩阵（自然坐标→物理坐标转换）"""
    jac = np.zeros((2, 2), dtype=FLOAT_TYPE)
    for i in range(4):
        jac[0, 0] += dN_ds[i] * elem_x[i]  # ∂x/∂s
        jac[0, 1] += dN_ds[i] * elem_y[i]  # ∂y/∂s
        jac[1, 0] += dN_dt[i] * elem_x[i]  # ∂x/∂t
        jac[1, 1] += dN_dt[i] * elem_y[i]  # ∂y/∂t
    
    det_jac = jac[0,0]*jac[1,1] - jac[0,1]*jac[1,0]
    if abs(det_jac) < TINY_VALUE:
        raise ValueError(f"雅可比行列式过小({det_jac:.2e})，数值不稳定")
    
    inv_jac = np.array([
        [jac[1,1]/det_jac, -jac[0,1]/det_jac],
        [-jac[1,0]/det_jac, jac[0,0]/det_jac]
    ], dtype=FLOAT_TYPE)
    
    return jac, det_jac, inv_jac

def calculate_B_matrix(dN_dx: np.ndarray, dN_dy: np.ndarray) -> np.ndarray:
    """计算平面应力问题的应变-位移矩阵B（ε = B·u）"""
    B = np.zeros((3, 8), dtype=FLOAT_TYPE)
    for i in range(4):
        u_idx = 2 * i
        v_idx = 2 * i + 1
        B[0, u_idx] = dN_dx[i]    # ε_xx = ∂u/∂x
        B[1, v_idx] = dN_dy[i]    # ε_yy = ∂v/∂y
        B[2, u_idx] = dN_dy[i]    # γ_xy = ∂u/∂y + ∂v/∂x
        B[2, v_idx] = dN_dx[i]
    return B

def calculate_surface_load(
    elem_x: np.ndarray,
    elem_y: np.ndarray,
    stress: float,
    thickness: float
) -> np.ndarray:
    """基于形函数积分计算面荷载的等效节点荷载（高精度）"""
    gauss_pts, gauss_wts = leggauss(2)
    elem_load = np.zeros(8, dtype=FLOAT_TYPE)
    
    for i, s in enumerate(gauss_pts):
        t = 1.0  # 顶部边自然坐标t=1
        weight = gauss_wts[i]
        
        N = quad4_shape_functions(s, t)
        dN_ds, _ = quad4_shape_derivatives(s, t)
        
        dx_ds = np.sum(dN_ds * elem_x)
        dy_ds = np.sum(dN_ds * elem_y)
        ds = np.sqrt(dx_ds**2 + dy_ds**2)
        
        for j in range(4):
            elem_load[2*j] += N[j] * stress * thickness * ds * weight
    
    return elem_load

def get_free_end_mid_disp(
    disp: np.ndarray,
    node_x: np.ndarray,
    node_y: np.ndarray
) -> Tuple[float, float]:
    """精准提取自由端（x=梁长）几何中点的位移（适配奇偶节点数）"""
    nx, ny = node_x.shape
    free_end_idx = []
    free_end_y = []
    free_end_dx = []
    free_end_dy = []
    
    for j in range(ny):
        global_idx = (nx-1)*ny + j
        if abs(node_x[nx-1, j] - BEAM_LENGTH) < TINY_VALUE:
            free_end_idx.append(global_idx)
            free_end_y.append(node_y[nx-1, j])
            free_end_dx.append(disp[2*global_idx, 0])
            free_end_dy.append(disp[2*global_idx+1, 0])
    
    free_end_y = np.array(free_end_y, dtype=FLOAT_TYPE)
    mid_y = (free_end_y.min() + free_end_y.max()) / 2.0
    
    interp_dx = interp1d(free_end_y, free_end_dx, kind='linear', fill_value="extrapolate")
    interp_dy = interp1d(free_end_y, free_end_dy, kind='linear', fill_value="extrapolate")
    
    return float(interp_dx(mid_y)), float(interp_dy(mid_y))

def print_result_compare(theory: Dict[str, float], fem: Dict[str, float]) -> None:
    """格式化打印有限元解与理论解的对比表格"""
    print("\n" + "="*85)
    print("有限元解与理论解对比表")
    print("="*85)
    print(f"{'分析项目':<25} {'理论解':<20} {'有限元解':<20} {'相对误差(%)':<15}")
    print("-"*85)
    
    for item in theory.keys():
        t_val = theory[item]
        f_val = fem[item]
        err = abs((f_val - t_val)/t_val)*100 if abs(t_val) > TINY_VALUE else 100.0
        print(f"{item:<25} {t_val:<20.8e} {f_val:<20.8e} {err:<15.4f}")
    
    print("="*85)


# ===================== 5. 可视化函数 =====================
def save_mesh_plot_with_annotations(
    node_x: np.ndarray,
    node_y: np.ndarray,
    top_nodes: list,
    elem_conn: list,
    global_load: np.ndarray,
    fixed_nodes: list,
    nx: int,
    ny: int
) -> None:
    """
    保存图1：原始网格与完整标注（单元/节点/荷载/约束）"""
    fig, ax = plt.subplots(figsize=(14, 8))  # 增大画布尺寸
    ax.set_title('原始网格与完整标注（单元/节点/荷载/约束）', fontsize=14, fontweight='bold', pad=15)
    ax.set_xlabel('x (m)', fontsize=12)
    ax.set_ylabel('y (m)', fontsize=12)
    
    # 1. 绘制网格线
    for i in range(nx):
        ax.plot(node_x[i, :], node_y[i, :], 'k-', linewidth=0.8, alpha=0.7)
    for j in range(ny):
        ax.plot(node_x[:, j], node_y[:, j], 'k-', linewidth=0.8, alpha=0.7)
    
    # 2. 标注节点编码（全局编号）
    node_flat_x = node_x.flatten()
    node_flat_y = node_y.flatten()
    for node_idx in range(nx*ny):
        ax.text(
            node_flat_x[node_idx] + 0.05, node_flat_y[node_idx] + 0.05,
            f"{node_idx+1}", fontsize=8, color='darkblue', fontweight='bold'
        )
    
    # 3. 标注单元划分与单元编号
    for elem_id, elem_nodes in enumerate(elem_conn):
        elem_node_idx = [n-1 for n in elem_nodes]
        elem_center_x = np.mean(node_flat_x[elem_node_idx])
        elem_center_y = np.mean(node_flat_y[elem_node_idx])
        ax.text(
            elem_center_x, elem_center_y, f"E{elem_id+1}",
            fontsize=9, color='darkgreen', fontweight='bold',
            bbox=dict(boxstyle="round,pad=0.2", facecolor='white', alpha=0.7)
        )
    
    # 4. 标注等效节点荷载（上表面节点，x方向荷载）
    arrow_length_scale = 1e-5  # 荷载箭头长度缩放因子
    for i, node_idx in enumerate(top_nodes):
        load_x = global_load[2*node_idx, 0]
        if abs(load_x) > TINY_VALUE:
            ax.arrow(
                node_flat_x[node_idx], node_flat_y[node_idx],
                load_x * arrow_length_scale, 0,
                head_width=0.03, head_length=0.08, fc='red', ec='red', alpha=0.8, zorder=5
            )
            ax.text(
                node_flat_x[node_idx] + 0.1, node_flat_y[node_idx] + 0.03,
                f"F={load_x:.1f}N", fontsize=7, color='red', fontweight='bold'
            )
    
    # 5. 标注位移约束（修改：仅保留红色十字叉，删除文字和背景框）
    for node_idx in fixed_nodes:
        ax.plot(
            node_flat_x[node_idx], node_flat_y[node_idx],
            'rx', markersize=8, markeredgewidth=2, zorder=6
        )
    
    # 6. 图例与样式设置
    ax.scatter([], [], c='darkblue', label='节点编码', s=20)
    ax.scatter([], [], c='darkgreen', label='单元编码', s=20)
    ax.arrow(0, 0, 0, 0, fc='red', ec='red', label='等效节点荷载', head_width=0.03)
    ax.plot([], [], 'rx', markersize=8, markeredgewidth=2, label='位移约束')
    # 调整图例位置到右上角外侧，避免重叠
    ax.legend(loc='upper left', bbox_to_anchor=(1.02, 1), fontsize=10, framealpha=0.9)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    # 修改：大幅增大显示范围（x轴-1.0~6.0，y轴-1.0~1.0），彻底避免图例重叠
    ax.set_xlim(-1.0, BEAM_LENGTH + 1.0)
    ax.set_ylim(-1.0, 1.0)
    
    filename = f'悬臂梁_原始网格_完整标注_{nx}x{ny}.png'
    plt.savefig(filename, dpi=300, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_disp_x_plot(node_x: np.ndarray, node_y: np.ndarray, disp_x: np.ndarray, nx: int, ny: int) -> None:
    """保存图2：水平位移云图"""
    fig, ax = plt.subplots(figsize=(10, 6))
    disp_contour = disp_x.reshape(nx, ny)
    contour = ax.contourf(node_x, node_y, disp_contour, levels=50, cmap='coolwarm')
    
    ax.set_title('水平位移 u_x 云图', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    cbar = plt.colorbar(contour, ax=ax, format='%.2e', shrink=0.8)
    cbar.set_label('位移值 (m)', rotation=270, labelpad=20)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    
    filename = f'悬臂梁_水平位移_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_stress_x_plot(node_x: np.ndarray, node_y: np.ndarray, stress_x: np.ndarray, nx: int, ny: int) -> None:
    """保存图3：轴向应力云图"""
    fig, ax = plt.subplots(figsize=(10, 6))
    stress_contour = stress_x.reshape(nx, ny)
    contour = ax.contourf(node_x, node_y, stress_contour, levels=50, cmap='RdBu_r')
    
    ax.set_title('轴向应力 σ_x 云图 (MPa)', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    cbar = plt.colorbar(contour, ax=ax, format='%.1f', shrink=0.8)
    cbar.set_label('应力值 (MPa)', rotation=270, labelpad=20)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    
    filename = f'悬臂梁_轴向应力_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_deformed_mesh_plot(
    node_x: np.ndarray,
    node_y: np.ndarray,
    def_x: np.ndarray,
    def_y: np.ndarray,
    nx: int,
    ny: int
) -> None:
    """保存图4：变形后网格 """
    fig, ax = plt.subplots(figsize=(10, 6))
    ax.set_title(f'变形后网格（位移放大{DISP_SCALE_FACTOR}倍）', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    
    # 修改：未变形网格改为黑色实线，线宽0.8（略细于变形网格）
    for i in range(nx):
        ax.plot(node_x[i, :], node_y[i, :], 'k-', linewidth=0.8, alpha=0.6)
    for j in range(ny):
        ax.plot(node_x[:, j], node_y[:, j], 'k-', linewidth=0.8, alpha=0.6)
    
    # 变形网格（红色实线，线宽1.5）
    def_x_scaled = node_x + (def_x - node_x) * DISP_SCALE_FACTOR
    def_y_scaled = node_y + (def_y - node_y) * DISP_SCALE_FACTOR
    for i in range(nx):
        ax.plot(def_x_scaled[i, :], def_y_scaled[i, :], 'r-', linewidth=1.5, alpha=0.8)
    for j in range(ny):
        ax.plot(def_x_scaled[:, j], def_y_scaled[:, j], 'r-', linewidth=1.5, alpha=0.8)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    ax.set_xlim(-1.0, BEAM_LENGTH + 1.0)
    ax.set_ylim(-1.0, 1.0)
    
    filename = f'悬臂梁_变形网格_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_disp_y_plot(node_x: np.ndarray, node_y: np.ndarray, disp_y: np.ndarray, nx: int, ny: int) -> None:
    """保存图5：竖向位移云图"""
    fig, ax = plt.subplots(figsize=(10, 6))
    disp_contour = disp_y.reshape(nx, ny)
    contour = ax.contourf(node_x, node_y, disp_contour, levels=50, cmap='coolwarm')
    
    ax.set_title('竖向位移 u_y 云图', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    cbar = plt.colorbar(contour, ax=ax, format='%.2e', shrink=0.8)
    cbar.set_label('位移值 (m)', rotation=270, labelpad=20)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    
    filename = f'悬臂梁_竖向位移_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_stress_xy_plot(node_x: np.ndarray, node_y: np.ndarray, stress_xy: np.ndarray, nx: int, ny: int) -> None:
    """保存图6：剪切应力云图"""
    fig, ax = plt.subplots(figsize=(10, 6))
    stress_contour = stress_xy.reshape(nx, ny)
    contour = ax.contourf(node_x, node_y, stress_contour, levels=50, cmap='viridis')
    
    ax.set_title('剪切应力 τ_xy 云图 (MPa)', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    cbar = plt.colorbar(contour, ax=ax, format='%.1f', shrink=0.8)
    cbar.set_label('应力值 (MPa)', rotation=270, labelpad=20)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    
    filename = f'悬臂梁_剪切应力_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()


# ===================== 6. 主分析流程 =====================
def run_fea_analysis() -> Dict[str, Any]:
    """悬臂梁平面应力有限元分析主函数"""
    print("="*60)
    print("等截面悬臂梁平面应力有限元分析程序 v2.4")
    print("="*60)
    
    try:
        # 1. 网格参数输入
        print("\n[1/6] 输入网格参数")
        print("-"*40)
        nx = get_valid_integer_input("水平方向节点数（≥2）: ")
        ny = get_valid_integer_input("竖直方向节点数（≥2）: ")
        
        ne_x = nx - 1
        ne_y = ny - 1
        n_nodes = nx * ny
        n_elems = ne_x * ne_y
        
        print(f"\n网格信息：")
        print(f"  节点数: {n_nodes} ({nx}×{ny}) | 单元数: {n_elems} ({ne_x}×{ne_y})")
        print(f"  提示：增加节点数可降低计算误差")
        
        # 2. 打印参数配置
        print("\n[2/6] 材料与几何参数")
        print("-"*40)
        print(f"几何参数：长度={BEAM_LENGTH}m | 高度={BEAM_HEIGHT}m | 厚度={BEAM_THICKNESS}m")
        print(f"材料参数：E={ELASTIC_MODULUS:.4e}Pa | ν={POISSON_RATIO} | 剪应力={APPLIED_SHEAR_STRESS:.4e}Pa")
        
        # 3. 理论解展示
        print("\n[3/6] 理论解")
        print("-"*40)
        theory = {
            "自由端水平位移(m)": THEORY_DISP_X,
            "自由端竖向位移(m)": THEORY_DISP_Y
        }
        for k, v in theory.items():
            print(f"  {k}: {v:.8e}")
        
        # 4. 生成网格
        print("\n[4/6] 生成有限元网格")
        print("-"*40)
        node_x = np.zeros((nx, ny), dtype=FLOAT_TYPE)
        node_y = np.zeros((nx, ny), dtype=FLOAT_TYPE)
        
        x_coords = np.linspace(0, BEAM_LENGTH, nx, dtype=FLOAT_TYPE)
        y_coords = np.linspace(-BEAM_HEIGHT/2, BEAM_HEIGHT/2, ny, dtype=FLOAT_TYPE)
        
        for i in range(nx):
            node_x[i, :] = x_coords[i]
        for j in range(ny):
            node_y[:, j] = y_coords[j]
        
        print(f"坐标范围：x=[{node_x.min():.6f}, {node_x.max():.6f}]m | y=[{node_y.min():.6f}, {node_y.max():.6f}]m")
        
        # 5. 生成单元连接表
        elem_conn = []
        for i in range(ne_x):
            for j in range(ne_y):
                n1 = i * ny + j + 1
                n2 = (i+1) * ny + j + 1
                n3 = (i+1) * ny + j + 2
                n4 = i * ny + j + 2
                elem_conn.append([n1, n2, n3, n4])
        
        # 6. 本构矩阵计算
        D = (ELASTIC_MODULUS / (1 - POISSON_RATIO**2)) * np.array([
            [1, POISSON_RATIO, 0],
            [POISSON_RATIO, 1, 0],
            [0, 0, (1-POISSON_RATIO)/2]
        ], dtype=FLOAT_TYPE)
        
        # 7. 高斯积分点初始化
        gauss_pts, gauss_wts = leggauss(GAUSS_ORDER)
        
        # 8. 组装全局刚度矩阵和荷载向量
        print("\n[5/6] 组装刚度矩阵与荷载向量")
        print("-"*40)
        K = np.zeros((2*n_nodes, 2*n_nodes), dtype=FLOAT_TYPE)
        F = np.zeros((2*n_nodes, 1), dtype=FLOAT_TYPE)
        
        for elem_id, elem_nodes in enumerate(elem_conn):
            if (elem_id+1) % max(1, n_elems//10) == 0:
                progress = (elem_id+1)/n_elems*100
                print(f"  处理单元 {elem_id+1}/{n_elems} ({progress:.0f}%)")
            
            elem_idx = [n-1 for n in elem_nodes]
            elem_x = node_x.flatten()[elem_idx]
            elem_y = node_y.flatten()[elem_idx]
            
            is_top_elem = np.max(elem_y) >= (BEAM_HEIGHT/2 - TINY_VALUE)
            ke = np.zeros((8, 8), dtype=FLOAT_TYPE)
            
            for i in range(GAUSS_ORDER):
                for j in range(GAUSS_ORDER):
                    s = gauss_pts[i]
                    t = gauss_pts[j]
                    
                    dN_ds, dN_dt = quad4_shape_derivatives(s, t)
                    jac, det_jac, inv_jac = calculate_jacobian(dN_ds, dN_dt, elem_x, elem_y)
                    
                    dN_dx = inv_jac[0,0]*dN_ds + inv_jac[0,1]*dN_dt
                    dN_dy = inv_jac[1,0]*dN_ds + inv_jac[1,1]*dN_dt
                    
                    B = calculate_B_matrix(dN_dx, dN_dy)
                    weight = gauss_wts[i] * gauss_wts[j] * det_jac * BEAM_THICKNESS
                    ke += B.T @ D @ B * weight
            
            if is_top_elem:
                fe = calculate_surface_load(elem_x, elem_y, APPLIED_SHEAR_STRESS, BEAM_THICKNESS)
                for local_i, global_i in enumerate(elem_idx):
                    F[2*global_i, 0] += fe[2*local_i]
                    F[2*global_i+1, 0] += fe[2*local_i+1]
            
            for local_i, global_i in enumerate(elem_idx):
                for local_j, global_j in enumerate(elem_idx):
                    K[2*global_i:2*global_i+2, 2*global_j:2*global_j+2] += ke[2*local_i:2*local_i+2, 2*local_j:2*local_j+2]
        
        # 9. 荷载信息
        total_load = np.sum(F)
        theory_load = APPLIED_SHEAR_STRESS * BEAM_THICKNESS * BEAM_LENGTH
        print(f"\n荷载信息：")
        print(f"  总施加荷载: {total_load:.6f}N | 理论总荷载: {theory_load:.6f}N")
        print(f"  荷载误差: {abs(total_load - theory_load):.6e}N")
        
        # 10. 边界条件处理（左端固定）
        print("\n[6/6] 求解位移与应力")
        print("-"*40)
        fixed_nodes = list(range(ny))  # 左端节点索引
        fixed_dofs = []
        for n in fixed_nodes:
            fixed_dofs.append(2*n)
            fixed_dofs.append(2*n+1)
        
        free_dofs = [d for d in range(2*n_nodes) if d not in fixed_dofs]
        K_red = K[np.ix_(free_dofs, free_dofs)]
        F_red = F[free_dofs, :]
        
        cond_num = np.linalg.cond(K_red)
        print(f"刚度矩阵条件数: {cond_num:.2e}")
        if cond_num > 1e10:
            print("警告：条件数较大，建议加密网格")
        
        # 求解位移
        u_red = np.linalg.solve(K_red, F_red)
        u = np.zeros((2*n_nodes, 1), dtype=FLOAT_TYPE)
        u[free_dofs, :] = u_red
        
        disp_x = u[::2].flatten()
        disp_y = u[1::2].flatten()
        
        print(f"\n位移范围：")
        print(f"  水平位移: [{disp_x.min():.8e}, {disp_x.max():.8e}]m")
        print(f"  竖向位移: [{disp_y.min():.8e}, {disp_y.max():.8e}]m")
        
        # 11. 提取自由端中点位移
        print("\n后处理：提取自由端中点位移")
        print("-"*40)
        fem_dx, fem_dy = get_free_end_mid_disp(u, node_x, node_y)
        fem = {
            "自由端水平位移(m)": fem_dx,
            "自由端竖向位移(m)": fem_dy
        }
        print(f"  水平位移: {fem_dx:.8e}m | 竖向位移: {fem_dy:.8e}m")
        
        # 12. 单元应力计算
        print("\n后处理：计算单元应力")
        print("-"*40)
        elem_stress = np.zeros((n_elems, 3), dtype=FLOAT_TYPE)
        
        for elem_id, elem_nodes in enumerate(elem_conn):
            elem_idx = [n-1 for n in elem_nodes]
            
            ue = np.zeros(8, dtype=FLOAT_TYPE)
            for local_i, global_i in enumerate(elem_idx):
                ue[2*local_i] = u[2*global_i, 0]
                ue[2*local_i+1] = u[2*global_i+1, 0]
            
            elem_x = node_x.flatten()[elem_idx]
            elem_y = node_y.flatten()[elem_idx]
            
            stress_avg = np.zeros(3, dtype=FLOAT_TYPE)
            count = 0
            
            for i in range(GAUSS_ORDER):
                for j in range(GAUSS_ORDER):
                    count += 1
                    s = gauss_pts[i]
                    t = gauss_pts[j]
                    
                    dN_ds, dN_dt = quad4_shape_derivatives(s, t)
                    jac, det_jac, inv_jac = calculate_jacobian(dN_ds, dN_dt, elem_x, elem_y)
                    
                    dN_dx = inv_jac[0,0]*dN_ds + inv_jac[0,1]*dN_dt
                    dN_dy = inv_jac[1,0]*dN_ds + inv_jac[1,1]*dN_dt
                    
                    B = calculate_B_matrix(dN_dx, dN_dy)
                    strain = B @ ue
                    stress = D @ strain
                    
                    stress_avg += stress
            
            elem_stress[elem_id, :] = stress_avg / count
        
        print(f"应力范围：")
        print(f"  轴向应力: [{elem_stress[:,0].min():.4e}, {elem_stress[:,0].max():.4e}]Pa")
        print(f"  剪切应力: [{elem_stress[:,2].min():.4e}, {elem_stress[:,2].max():.4e}]Pa")
        
        # 13. 结果对比
        print_result_compare(theory, fem)
        
        # 14. 误差分析
        dx_err = abs((fem_dx - THEORY_DISP_X)/THEORY_DISP_X)*100
        dy_err = abs((fem_dy - THEORY_DISP_Y)/THEORY_DISP_Y)*100
        print(f"\n误差分析：")
        print(f"  水平位移相对误差: {dx_err:.4f}%")
        print(f"  竖向位移相对误差: {dy_err:.4f}%")
        if dx_err < 1.0:
            print(f"  ✅ 水平位移误差<1%，满足工程精度要求")
        
        # 15. 可视化准备
        print("\n生成可视化结果")
        print("-"*40)
        
        def_x = node_x.flatten() + disp_x
        def_y = node_y.flatten() + disp_y
        def_x = def_x.reshape(nx, ny)
        def_y = def_y.reshape(nx, ny)
        
        # 节点应力平均
        node_stress_x = np.zeros(n_nodes, dtype=FLOAT_TYPE)
        node_stress_xy = np.zeros(n_nodes, dtype=FLOAT_TYPE)
        node_count_x = np.zeros(n_nodes, dtype=int)
        node_count_xy = np.zeros(n_nodes, dtype=int)
        
        for elem_id, elem_nodes in enumerate(elem_conn):
            sx = elem_stress[elem_id, 0]
            sxy = elem_stress[elem_id, 2]
            for n in elem_nodes:
                idx = n-1
                node_stress_x[idx] += sx
                node_stress_xy[idx] += sxy
                node_count_x[idx] += 1
                node_count_xy[idx] += 1
        
        node_stress_x_avg = node_stress_x / node_count_x / 1e6
        node_stress_xy_avg = node_stress_xy / node_count_xy / 1e6
        
        top_nodes = [i*ny + (ny-1) for i in range(nx)]  # 上表面节点索引
        
        # 调用可视化函数（删除了冗余的网格划分与单元图）
        print("\n保存图片文件：")
        print("-"*40)
        save_mesh_plot_with_annotations(node_x, node_y, top_nodes, elem_conn, F, fixed_nodes, nx, ny)
        save_disp_x_plot(node_x, node_y, disp_x, nx, ny)
        save_stress_x_plot(node_x, node_y, node_stress_x_avg, nx, ny)
        save_deformed_mesh_plot(node_x, node_y, def_x, def_y, nx, ny)
        save_disp_y_plot(node_x, node_y, disp_y, nx, ny)
        save_stress_xy_plot(node_x, node_y, node_stress_xy_avg, nx, ny)
        
        # 返回分析结果
        return {
            'nodal_displacements': u,
            'element_stresses': elem_stress,
            'mesh_info': {'nx': nx, 'ny': ny, 'n_nodes': n_nodes, 'n_elems': n_elems},
            'theory_solution': theory,
            'fem_solution': fem,
            'error': {'dx_err': dx_err, 'dy_err': dy_err}
        }
    
    except Exception as e:
        print(f"\n程序执行错误: {str(e)}")
        traceback.print_exc()
        return None


# ===================== 7. 程序入口 =====================
if __name__ == "__main__":
    results = run_fea_analysis()
    if results:
        print("\n✅ 悬臂梁有限元分析完成！")
        if results['error']['dx_err'] < 1.0:
            print(f"📊 水平位移相对误差 {results['error']['dx_err']:.4f}%，达到高精度要求")
    else:
        print("\n❌ 程序执行失败，请检查错误信息")

2.2 三结点三边形单元有限元Python程序

  源代码已上传github，详见链接。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
"""
等截面悬臂梁平面应力有限元分析程序（三结点三角形单元版 v2.4.2）

核心功能：
1. 基于四节点三角形单元实现悬臂梁平面应力有限元全流程分析
2. 保留原程序的高精度位移提取、可视化、结果对比功能
3. 生成6张高清可视化图片
"""


# ===================== 1. 导入依赖库 =====================
import traceback
from typing import Tuple, Dict, Any

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from numpy.polynomial.legendre import leggauss
from scipy.interpolate import interp1d


# ===================== 2. 全局配置 =====================
# 绘图配置
matplotlib.rcParams['font.sans-serif'] = ['Microsoft YaHei', 'SimHei', 'PingFang SC']
matplotlib.rcParams['axes.unicode_minus'] = False
matplotlib.rcParams['figure.dpi'] = 120
matplotlib.rcParams['savefig.dpi'] = 300

# 几何参数（与理论解严格匹配）
BEAM_LENGTH = 5.0          # 梁总长 (m)
BEAM_HEIGHT = 1.0          # 梁截面高度 (m)
BEAM_THICKNESS = 0.1       # 梁厚度（平面应力）(m)

# 材料参数
ELASTIC_MODULUS = 190e9    # 弹性模量 (Pa)
POISSON_RATIO = 0.25       # 泊松比
APPLIED_SHEAR_STRESS = 10e6  # 顶部剪应力 (Pa)

# 理论解（基于上述参数推导）
THEORY_DISP_X = 0.00131578947368  # 自由端水平位移 (m)
THEORY_DISP_Y = -0.0130921052632  # 自由端竖向位移 (m)

# 数值计算参数（三角形单元适配）
TRI_INTEG_ORDER = 1        # 三角形1点积分（常应变单元最优）
TINY_VALUE = 1e-15         # 数值稳定性极小值
FLOAT_TYPE = np.float64    # 双精度浮点类型
DISP_SCALE_FACTOR = 10     # 位移放大因子

# 三角形单元高斯积分点（面积坐标）和权重
TRI_INTEG_POINTS = np.array([[1/3, 1/3, 1/3]], dtype=FLOAT_TYPE)  # 1点积分（单元中心）
TRI_INTEG_WEIGHTS = np.array([1/2], dtype=FLOAT_TYPE)             # 积分权重


# ===================== 3. 输入处理工具函数 =====================
def get_valid_integer_input(prompt: str, min_value: int = 2) -> int:
    """
    获取用户输入的有效正整数，包含输入合法性验证
    
    Args:
        prompt: 输入提示文本
        min_value: 输入最小值（默认2，保证至少1个单元）
    
    Returns:
        验证通过的正整数
    """
    while True:
        try:
            user_input = int(input(prompt))
            if user_input >= min_value:
                return user_input
            print(f"错误：数值必须≥{min_value}，请重新输入")
        except ValueError:
            print("错误：请输入有效正整数（如5、10、20）")


# ===================== 4. 三角形单元核心计算函数 =====================
def tri3_shape_functions(l1: float, l2: float, l3: float) -> np.ndarray:
    """计算3节点三角形单元形函数值（面积坐标L1,L2,L3）"""
    # 三角形线性形函数：N1=L1, N2=L2, N3=L3
    return np.array([l1, l2, l3], dtype=FLOAT_TYPE)

def tri3_shape_derivatives(elem_x: np.ndarray, elem_y: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
    """
    计算3节点三角形单元形函数对物理坐标的偏导数
    公式：dN/dx = (1/2A) * [ (y2-y3), (y3-y1), (y1-y2) ]
          dN/dy = (1/2A) * [ (x3-x2), (x1-x3), (x2-x1) ]
    """
    # 单元节点坐标
    x1, x2, x3 = elem_x
    y1, y2, y3 = elem_y
    
    # 单元面积×2
    two_A = (x2 - x1)*(y3 - y1) - (x3 - x1)*(y2 - y1)
    if abs(two_A) < TINY_VALUE:
        raise ValueError(f"三角形单元面积过小({two_A:.2e})，数值不稳定")
    
    # 形函数对x/y的偏导数
    dN_dx = np.array([
        (y2 - y3)/two_A,
        (y3 - y1)/two_A,
        (y1 - y2)/two_A
    ], dtype=FLOAT_TYPE)
    
    dN_dy = np.array([
        (x3 - x2)/two_A,
        (x1 - x3)/two_A,
        (x2 - x1)/two_A
    ], dtype=FLOAT_TYPE)
    
    return dN_dx, dN_dy

def calculate_tri_B_matrix(dN_dx: np.ndarray, dN_dy: np.ndarray) -> np.ndarray:
    """计算三角形单元应变-位移矩阵B（ε = B·u，3×6维度）"""
    B = np.zeros((3, 6), dtype=FLOAT_TYPE)
    for i in range(3):
        u_idx = 2 * i
        v_idx = 2 * i + 1
        B[0, u_idx] = dN_dx[i]    # ε_xx = ∂u/∂x
        B[1, v_idx] = dN_dy[i]    # ε_yy = ∂v/∂y
        B[2, u_idx] = dN_dy[i]    # γ_xy = ∂u/∂y + ∂v/∂x
        B[2, v_idx] = dN_dx[i]
    return B

def calculate_tri_surface_load(
    elem_x: np.ndarray,
    elem_y: np.ndarray,
    stress: float,
    thickness: float,
    is_top_edge: bool
) -> np.ndarray:
    """计算三角形单元面荷载的等效节点荷载（顶部边荷载）"""
    elem_load = np.zeros(6, dtype=FLOAT_TYPE)
    
    # 确定顶部边的两个节点（y坐标最大的两个节点）
    if is_top_edge:
        y_vals = elem_y
        top_node_idx = np.argsort(y_vals)[-2:]  # 取y最大的两个节点
        x1, x2 = elem_x[top_node_idx]
        y1, y2 = elem_y[top_node_idx]
        
        # 边长度
        edge_len = np.sqrt((x2-x1)**2 + (y2-y1)**2)
        # 均布荷载等效到两个节点（各承担一半）
        load_mag = stress * thickness * edge_len / 2.0
        
        for idx in top_node_idx:
            elem_load[2*idx] = load_mag  # x方向荷载
    
    return elem_load

def get_free_end_mid_disp(
    disp: np.ndarray,
    node_x: np.ndarray,
    node_y: np.ndarray
) -> Tuple[float, float]:
    """精准提取自由端（x=梁长）几何中点的位移（适配奇偶节点数）"""
    nx, ny = node_x.shape
    free_end_idx = []
    free_end_y = []
    free_end_dx = []
    free_end_dy = []
    
    for j in range(ny):
        global_idx = (nx-1)*ny + j
        if abs(node_x[nx-1, j] - BEAM_LENGTH) < TINY_VALUE:
            free_end_idx.append(global_idx)
            free_end_y.append(node_y[nx-1, j])
            free_end_dx.append(disp[2*global_idx, 0])
            free_end_dy.append(disp[2*global_idx+1, 0])
    
    free_end_y = np.array(free_end_y, dtype=FLOAT_TYPE)
    mid_y = (free_end_y.min() + free_end_y.max()) / 2.0
    
    interp_dx = interp1d(free_end_y, free_end_dx, kind='linear', fill_value="extrapolate")
    interp_dy = interp1d(free_end_y, free_end_dy, kind='linear', fill_value="extrapolate")
    
    return float(interp_dx(mid_y)), float(interp_dy(mid_y))

def print_result_compare(theory: Dict[str, float], fem: Dict[str, float]) -> None:
    """格式化打印有限元解与理论解的对比表格"""
    print("\n" + "="*85)
    print("有限元解与理论解对比表（三结点三角形单元）")
    print("="*85)
    print(f"{'分析项目':<25} {'理论解':<20} {'有限元解':<20} {'相对误差(%)':<15}")
    print("-"*85)
    
    for item in theory.keys():
        t_val = theory[item]
        f_val = fem[item]
        err = abs((f_val - t_val)/t_val)*100 if abs(t_val) > TINY_VALUE else 100.0
        print(f"{item:<25} {t_val:<20.8e} {f_val:<20.8e} {err:<15.4f}")
    
    print("="*85)


# ===================== 5. 可视化函数 =====================
def save_mesh_plot_with_annotations(
    node_x: np.ndarray,
    node_y: np.ndarray,
    top_nodes: list,
    elem_conn: list,
    global_load: np.ndarray,
    fixed_nodes: list,
    nx: int,
    ny: int
) -> None:
    """保存图1：原始网格与完整标注（三角形单元适配）"""
    fig, ax = plt.subplots(figsize=(14, 8))
    ax.set_title('原始网格与完整标注（三结点三角形单元）', fontsize=14, fontweight='bold', pad=15)
    ax.set_xlabel('x (m)', fontsize=12)
    ax.set_ylabel('y (m)', fontsize=12)
    
    # 1. 绘制三角形单元网格
    for elem_nodes in elem_conn:
        elem_idx = [n-1 for n in elem_nodes]
        elem_x = node_x.flatten()[elem_idx]
        elem_y = node_y.flatten()[elem_idx]
        # 闭合三角形绘制
        elem_x_plot = np.append(elem_x, elem_x[0])
        elem_y_plot = np.append(elem_y, elem_y[0])
        ax.plot(elem_x_plot, elem_y_plot, 'k-', linewidth=0.8, alpha=0.7)
    
    # 2. 标注节点编码（全局编号）
    node_flat_x = node_x.flatten()
    node_flat_y = node_y.flatten()
    for node_idx in range(nx*ny):
        ax.text(
            node_flat_x[node_idx] + 0.05, node_flat_y[node_idx] + 0.05,
            f"{node_idx+1}", fontsize=8, color='darkblue', fontweight='bold'
        )
    
    # 3. 标注单元编号
    for elem_id, elem_nodes in enumerate(elem_conn):
        elem_idx = [n-1 for n in elem_nodes]
        elem_center_x = np.mean(node_x.flatten()[elem_idx])
        elem_center_y = np.mean(node_y.flatten()[elem_idx])
        ax.text(
            elem_center_x, elem_center_y, f"E{elem_id+1}",
            fontsize=8, color='darkgreen', fontweight='bold',
            bbox=dict(boxstyle="round,pad=0.2", facecolor='white', alpha=0.7)
        )
    
    # 4. 标注等效节点荷载
    arrow_length_scale = 1e-5
    for i, node_idx in enumerate(top_nodes):
        load_x = global_load[2*node_idx, 0]
        if abs(load_x) > TINY_VALUE:
            ax.arrow(
                node_flat_x[node_idx], node_flat_y[node_idx],
                load_x * arrow_length_scale, 0,
                head_width=0.03, head_length=0.08, fc='red', ec='red', alpha=0.8, zorder=5
            )
            ax.text(
                node_flat_x[node_idx] + 0.1, node_flat_y[node_idx] + 0.03,
                f"F={load_x:.1f}N", fontsize=7, color='red', fontweight='bold'
            )
    
    # 5. 标注位移约束（仅红色十字叉）
    for node_idx in fixed_nodes:
        ax.plot(
            node_flat_x[node_idx], node_flat_y[node_idx],
            'rx', markersize=8, markeredgewidth=2, zorder=6
        )
    
    # 6. 图例与样式设置
    ax.scatter([], [], c='darkblue', label='节点编码', s=20)
    ax.scatter([], [], c='darkgreen', label='单元编码', s=20)
    ax.arrow(0, 0, 0, 0, fc='red', ec='red', label='等效节点荷载', head_width=0.03)
    ax.plot([], [], 'rx', markersize=8, markeredgewidth=2, label='位移约束')
    ax.legend(loc='upper left', bbox_to_anchor=(1.02, 1), fontsize=10, framealpha=0.9)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    ax.set_xlim(-1.0, BEAM_LENGTH + 1.0)
    ax.set_ylim(-1.0, 1.0)
    
    filename = f'悬臂梁_原始网格_三角形单元_{nx}x{ny}.png'
    plt.savefig(filename, dpi=300, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_disp_x_plot(node_x: np.ndarray, node_y: np.ndarray, disp_x: np.ndarray, nx: int, ny: int) -> None:
    """保存图2：水平位移云图"""
    fig, ax = plt.subplots(figsize=(10, 6))
    disp_contour = disp_x.reshape(nx, ny)
    contour = ax.contourf(node_x, node_y, disp_contour, levels=50, cmap='coolwarm')
    
    ax.set_title('水平位移 u_x 云图（三角形单元）', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    cbar = plt.colorbar(contour, ax=ax, format='%.2e', shrink=0.8)
    cbar.set_label('位移值 (m)', rotation=270, labelpad=20)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    
    filename = f'悬臂梁_水平位移_三角形单元_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_stress_x_plot(node_x: np.ndarray, node_y: np.ndarray, stress_x: np.ndarray, nx: int, ny: int) -> None:
    """保存图3：轴向应力云图"""
    fig, ax = plt.subplots(figsize=(10, 6))
    stress_contour = stress_x.reshape(nx, ny)
    contour = ax.contourf(node_x, node_y, stress_contour, levels=50, cmap='RdBu_r')
    
    ax.set_title('轴向应力 σ_x 云图 (MPa)（三角形单元）', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    cbar = plt.colorbar(contour, ax=ax, format='%.1f', shrink=0.8)
    cbar.set_label('应力值 (MPa)', rotation=270, labelpad=20)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    
    filename = f'悬臂梁_轴向应力_三角形单元_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_deformed_mesh_plot(
    node_x: np.ndarray,
    node_y: np.ndarray,
    def_x: np.ndarray,
    def_y: np.ndarray,
    elem_conn: list,  # 修复：添加elem_conn参数
    nx: int,
    ny: int
) -> None:
    """保存图4：变形后网格（三角形单元适配）"""
    fig, ax = plt.subplots(figsize=(10, 6))
    ax.set_title(f'变形后网格（位移放大{DISP_SCALE_FACTOR}倍，三角形单元）', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    
    # 未变形网格（黑色实线）
    node_flat_x = node_x.flatten()
    node_flat_y = node_y.flatten()
    for elem_nodes in elem_conn:
        elem_idx = [n-1 for n in elem_nodes]
        elem_x = node_flat_x[elem_idx]
        elem_y = node_flat_y[elem_idx]
        elem_x_plot = np.append(elem_x, elem_x[0])
        elem_y_plot = np.append(elem_y, elem_y[0])
        ax.plot(elem_x_plot, elem_y_plot, 'k-', linewidth=0.8, alpha=0.6)
    
    # 变形网格（红色实线）
    def_flat_x = def_x.flatten()
    def_flat_y = def_y.flatten()
    def_x_scaled = def_flat_x + (def_flat_x - node_flat_x) * (DISP_SCALE_FACTOR - 1)
    def_y_scaled = def_flat_y + (def_flat_y - node_flat_y) * (DISP_SCALE_FACTOR - 1)
    for elem_nodes in elem_conn:
        elem_idx = [n-1 for n in elem_nodes]
        elem_x = def_x_scaled[elem_idx]
        elem_y = def_y_scaled[elem_idx]
        elem_x_plot = np.append(elem_x, elem_x[0])
        elem_y_plot = np.append(elem_y, elem_y[0])
        ax.plot(elem_x_plot, elem_y_plot, 'r-', linewidth=1.5, alpha=0.8)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    ax.set_xlim(-1.0, BEAM_LENGTH + 1.0)
    ax.set_ylim(-1.0, 1.0)
    
    filename = f'悬臂梁_变形网格_三角形单元_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_disp_y_plot(node_x: np.ndarray, node_y: np.ndarray, disp_y: np.ndarray, nx: int, ny: int) -> None:
    """保存图5：竖向位移云图"""
    fig, ax = plt.subplots(figsize=(10, 6))
    disp_contour = disp_y.reshape(nx, ny)
    contour = ax.contourf(node_x, node_y, disp_contour, levels=50, cmap='coolwarm')
    
    ax.set_title('竖向位移 u_y 云图（三角形单元）', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    cbar = plt.colorbar(contour, ax=ax, format='%.2e', shrink=0.8)
    cbar.set_label('位移值 (m)', rotation=270, labelpad=20)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    
    filename = f'悬臂梁_竖向位移_三角形单元_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()

def save_stress_xy_plot(node_x: np.ndarray, node_y: np.ndarray, stress_xy: np.ndarray, nx: int, ny: int) -> None:
    """保存图6：剪切应力云图"""
    fig, ax = plt.subplots(figsize=(10, 6))
    stress_contour = stress_xy.reshape(nx, ny)
    contour = ax.contourf(node_x, node_y, stress_contour, levels=50, cmap='viridis')
    
    ax.set_title('剪切应力 τ_xy 云图 (MPa)（三角形单元）', fontsize=14, fontweight='bold')
    ax.set_xlabel('x (m)')
    ax.set_ylabel('y (m)')
    cbar = plt.colorbar(contour, ax=ax, format='%.1f', shrink=0.8)
    cbar.set_label('应力值 (MPa)', rotation=270, labelpad=20)
    
    ax.set_aspect('equal')
    ax.grid(True, alpha=0.3, linestyle='--')
    
    filename = f'悬臂梁_剪切应力_三角形单元_{nx}x{ny}.png'
    plt.savefig(filename, bbox_inches='tight')
    print(f"已保存: {filename}")
    plt.close()


# ===================== 6. 主分析流程 =====================
def run_fea_analysis() -> Dict[str, Any]:
    """悬臂梁平面应力有限元分析主函数（三结点三角形单元）"""
    print("="*60)
    print("等截面悬臂梁平面应力有限元分析程序（三结点三角形单元版）")
    print("="*60)
    
    try:
        # 1. 网格参数输入
        print("\n[1/6] 输入网格参数")
        print("-"*40)
        nx = get_valid_integer_input("水平方向节点数（≥2）: ")
        ny = get_valid_integer_input("竖直方向节点数（≥2）: ")
        
        ne_x = nx - 1
        ne_y = ny - 1
        n_nodes = nx * ny
        n_elems = 2 * ne_x * ne_y  # 每个四边形拆分为2个三角形
        
        print(f"\n网格信息：")
        print(f"  节点数: {n_nodes} ({nx}×{ny}) | 三角形单元数: {n_elems} ({2*ne_x}×{ne_y})")
        print(f"  提示：增加节点数可降低计算误差（三角形单元收敛速度较慢）")
        
        # 2. 打印参数配置
        print("\n[2/6] 材料与几何参数")
        print("-"*40)
        print(f"几何参数：长度={BEAM_LENGTH}m | 高度={BEAM_HEIGHT}m | 厚度={BEAM_THICKNESS}m")
        print(f"材料参数：E={ELASTIC_MODULUS:.4e}Pa | ν={POISSON_RATIO} | 剪应力={APPLIED_SHEAR_STRESS:.4e}Pa")
        
        # 3. 理论解展示
        print("\n[3/6] 理论解")
        print("-"*40)
        theory = {
            "自由端水平位移(m)": THEORY_DISP_X,
            "自由端竖向位移(m)": THEORY_DISP_Y
        }
        for k, v in theory.items():
            print(f"  {k}: {v:.8e}")
        
        # 4. 生成网格
        print("\n[4/6] 生成三角形有限元网格")
        print("-"*40)
        node_x = np.zeros((nx, ny), dtype=FLOAT_TYPE)
        node_y = np.zeros((nx, ny), dtype=FLOAT_TYPE)
        
        x_coords = np.linspace(0, BEAM_LENGTH, nx, dtype=FLOAT_TYPE)
        y_coords = np.linspace(-BEAM_HEIGHT/2, BEAM_HEIGHT/2, ny, dtype=FLOAT_TYPE)
        
        for i in range(nx):
            node_x[i, :] = x_coords[i]
        for j in range(ny):
            node_y[:, j] = y_coords[j]
        
        print(f"坐标范围：x=[{node_x.min():.6f}, {node_x.max():.6f}]m | y=[{node_y.min():.6f}, {node_y.max():.6f}]m")
        
        # 5. 生成三角形单元连接表（每个四边形拆分为2个三角形）
        elem_conn = []
        for i in range(ne_x):
            for j in range(ne_y):
                # 四边形节点：n1, n2, n3, n4
                n1 = i * ny + j + 1
                n2 = (i+1) * ny + j + 1
                n3 = (i+1) * ny + j + 2
                n4 = i * ny + j + 2
                
                # 拆分为两个三角形：n1-n2-n3 和 n1-n3-n4
                elem_conn.append([n1, n2, n3])
                elem_conn.append([n1, n3, n4])
        
        # 6. 本构矩阵计算（与原程序一致）
        D = (ELASTIC_MODULUS / (1 - POISSON_RATIO**2)) * np.array([
            [1, POISSON_RATIO, 0],
            [POISSON_RATIO, 1, 0],
            [0, 0, (1-POISSON_RATIO)/2]
        ], dtype=FLOAT_TYPE)
        
        # 7. 组装全局刚度矩阵和荷载向量
        print("\n[5/6] 组装刚度矩阵与荷载向量")
        print("-"*40)
        K = np.zeros((2*n_nodes, 2*n_nodes), dtype=FLOAT_TYPE)
        F = np.zeros((2*n_nodes, 1), dtype=FLOAT_TYPE)
        
        for elem_id, elem_nodes in enumerate(elem_conn):
            if (elem_id+1) % max(1, n_elems//10) == 0:
                progress = (elem_id+1)/n_elems*100
                print(f"  处理单元 {elem_id+1}/{n_elems} ({progress:.0f}%)")
            
            elem_idx = [n-1 for n in elem_nodes]
            elem_x = node_x.flatten()[elem_idx]
            elem_y = node_y.flatten()[elem_idx]
            
            # 判断是否为顶部单元（有顶部边）
            is_top_elem = np.max(elem_y) >= (BEAM_HEIGHT/2 - TINY_VALUE)
            
            # 计算单元刚度矩阵（三角形1点积分）
            ke = np.zeros((6, 6), dtype=FLOAT_TYPE)
            dN_dx, dN_dy = tri3_shape_derivatives(elem_x, elem_y)
            B = calculate_tri_B_matrix(dN_dx, dN_dy)
            
            # 三角形单元面积
            two_A = (elem_x[1]-elem_x[0])*(elem_y[2]-elem_y[0]) - (elem_x[2]-elem_x[0])*(elem_y[1]-elem_y[0])
            area = abs(two_A) / 2.0
            
            # 刚度矩阵（常应变单元，积分后简化）
            ke = B.T @ D @ B * area * BEAM_THICKNESS
            
            # 计算面荷载（顶部单元）
            if is_top_elem:
                fe = calculate_tri_surface_load(elem_x, elem_y, APPLIED_SHEAR_STRESS, BEAM_THICKNESS, is_top_elem)
                for local_i, global_i in enumerate(elem_idx):
                    F[2*global_i, 0] += fe[2*local_i]
                    F[2*global_i+1, 0] += fe[2*local_i+1]
            
            # 组装全局刚度矩阵
            for local_i, global_i in enumerate(elem_idx):
                for local_j, global_j in enumerate(elem_idx):
                    K[2*global_i:2*global_i+2, 2*global_j:2*global_j+2] += ke[2*local_i:2*local_i+2, 2*local_j:2*local_j+2]
        
        # 8. 荷载信息
        total_load = np.sum(F)
        theory_load = APPLIED_SHEAR_STRESS * BEAM_THICKNESS * BEAM_LENGTH
        print(f"\n荷载信息：")
        print(f"  总施加荷载: {total_load:.6f}N | 理论总荷载: {theory_load:.6f}N")
        print(f"  荷载误差: {abs(total_load - theory_load):.6e}N")
        
        # 9. 边界条件处理（左端固定）
        print("\n[6/6] 求解位移与应力")
        print("-"*40)
        fixed_nodes = list(range(ny))  # 左端节点索引
        fixed_dofs = []
        for n in fixed_nodes:
            fixed_dofs.append(2*n)
            fixed_dofs.append(2*n+1)
        
        free_dofs = [d for d in range(2*n_nodes) if d not in fixed_dofs]
        K_red = K[np.ix_(free_dofs, free_dofs)]
        F_red = F[free_dofs, :]
        
        cond_num = np.linalg.cond(K_red)
        print(f"刚度矩阵条件数: {cond_num:.2e}")
        if cond_num > 1e10:
            print("警告：条件数较大，建议加密网格")
        
        # 求解位移
        u_red = np.linalg.solve(K_red, F_red)
        u = np.zeros((2*n_nodes, 1), dtype=FLOAT_TYPE)
        u[free_dofs, :] = u_red
        
        disp_x = u[::2].flatten()
        disp_y = u[1::2].flatten()
        
        print(f"\n位移范围：")
        print(f"  水平位移: [{disp_x.min():.8e}, {disp_x.max():.8e}]m")
        print(f"  竖向位移: [{disp_y.min():.8e}, {disp_y.max():.8e}]m")
        
        # 10. 提取自由端中点位移
        print("\n后处理：提取自由端中点位移")
        print("-"*40)
        fem_dx, fem_dy = get_free_end_mid_disp(u, node_x, node_y)
        fem = {
            "自由端水平位移(m)": fem_dx,
            "自由端竖向位移(m)": fem_dy
        }
        print(f"  水平位移: {fem_dx:.8e}m | 竖向位移: {fem_dy:.8e}m")
        
        # 11. 单元应力计算
        print("\n后处理：计算单元应力")
        print("-"*40)
        elem_stress = np.zeros((n_elems, 3), dtype=FLOAT_TYPE)
        
        for elem_id, elem_nodes in enumerate(elem_conn):
            elem_idx = [n-1 for n in elem_nodes]
            
            ue = np.zeros(6, dtype=FLOAT_TYPE)
            for local_i, global_i in enumerate(elem_idx):
                ue[2*local_i] = u[2*global_i, 0]
                ue[2*local_i+1] = u[2*global_i+1, 0]
            
            elem_x = node_x.flatten()[elem_idx]
            elem_y = node_y.flatten()[elem_idx]
            
            dN_dx, dN_dy = tri3_shape_derivatives(elem_x, elem_y)
            B = calculate_tri_B_matrix(dN_dx, dN_dy)
            
            strain = B @ ue
            stress = D @ strain
            elem_stress[elem_id, :] = stress
        
        print(f"应力范围：")
        print(f"  轴向应力: [{elem_stress[:,0].min():.4e}, {elem_stress[:,0].max():.4e}]Pa")
        print(f"  剪切应力: [{elem_stress[:,2].min():.4e}, {elem_stress[:,2].max():.4e}]Pa")
        
        # 12. 结果对比
        print_result_compare(theory, fem)
        
        # 13. 误差分析
        dx_err = abs((fem_dx - THEORY_DISP_X)/THEORY_DISP_X)*100
        dy_err = abs((fem_dy - THEORY_DISP_Y)/THEORY_DISP_Y)*100
        print(f"\n误差分析：")
        print(f"  水平位移相对误差: {dx_err:.4f}%")
        print(f"  竖向位移相对误差: {dy_err:.4f}%")
        if dx_err < 5.0:  # 三角形单元误差容忍度更高
            print(f"  ✅ 水平位移误差<5%，满足工程精度要求")
        
        # 14. 可视化准备
        print("\n生成可视化结果")
        print("-"*40)
        
        def_x = node_x + disp_x.reshape(nx, ny)
        def_y = node_y + disp_y.reshape(nx, ny)
        
        # 节点应力平均
        node_stress_x = np.zeros(n_nodes, dtype=FLOAT_TYPE)
        node_stress_xy = np.zeros(n_nodes, dtype=FLOAT_TYPE)
        node_count_x = np.zeros(n_nodes, dtype=int)
        node_count_xy = np.zeros(n_nodes, dtype=int)
        
        for elem_id, elem_nodes in enumerate(elem_conn):
            sx = elem_stress[elem_id, 0]
            sxy = elem_stress[elem_id, 2]
            for n in elem_nodes:
                idx = n-1
                node_stress_x[idx] += sx
                node_stress_xy[idx] += sxy
                node_count_x[idx] += 1
                node_count_xy[idx] += 1
        
        node_stress_x_avg = node_stress_x / node_count_x / 1e6
        node_stress_xy_avg = node_stress_xy / node_count_xy / 1e6
        
        top_nodes = [i*ny + (ny-1) for i in range(nx)]  # 上表面节点索引
        
        # 调用可视化函数（修复：传入elem_conn参数）
        print("\n保存图片文件：")
        print("-"*40)
        save_mesh_plot_with_annotations(node_x, node_y, top_nodes, elem_conn, F, fixed_nodes, nx, ny)
        save_disp_x_plot(node_x, node_y, disp_x, nx, ny)
        save_stress_x_plot(node_x, node_y, node_stress_x_avg, nx, ny)
        save_deformed_mesh_plot(node_x, node_y, def_x, def_y, elem_conn, nx, ny)  # 修复：传入elem_conn
        save_disp_y_plot(node_x, node_y, disp_y, nx, ny)
        save_stress_xy_plot(node_x, node_y, node_stress_xy_avg, nx, ny)
        
        # 返回分析结果
        return {
            'nodal_displacements': u,
            'element_stresses': elem_stress,
            'mesh_info': {'nx': nx, 'ny': ny, 'n_nodes': n_nodes, 'n_elems': n_elems},
            'theory_solution': theory,
            'fem_solution': fem,
            'error': {'dx_err': dx_err, 'dy_err': dy_err}
        }
    
    except Exception as e:
        print(f"\n程序执行错误: {str(e)}")
        traceback.print_exc()
        return None


# ===================== 7. 程序入口 =====================
if __name__ == "__main__":
    results = run_fea_analysis()
    if results:
        print("\n✅ 悬臂梁有限元分析完成（三结点三角形单元）！")
        if results['error']['dx_err'] < 5.0:
            print(f"📊 水平位移相对误差 {results['error']['dx_err']:.4f}%，达到工程精度要求")
    else:
        print("\n❌ 程序执行失败，请检查错误信息")

3 Python程序运行结果

  共计算三组：四边形四结点单元（网格 10×5）、四边形四结点单元（网格 20×10）、三结点三角形单元（网格 10×5）。自由端中点位移与理论解的对比汇总如下。

表3.1 三种网格方案自由端中点位移汇总

计算方案水平位移(m)相对误差竖向位移(m)相对误差
理论解1.3158×10−31.3158\times10^{-3}−-−1.3092×10−2-1.3092\times10^{-2}−-
四边形 10×56.4705×10−46.4705\times10^{-4}50.82%50.82\%−1.1598×10−2-1.1598\times10^{-2}11.41%11.41\%
四边形 20×106.4756×10−46.4756\times10^{-4}50.79%50.79\%−1.2785×10−2-1.2785\times10^{-2}2.35%2.35\%
三角形 10×59.6208×10−49.6208\times10^{-4}26.88%26.88\%−1.1778×10−2-1.1778\times10^{-2}10.04%10.04\%

  下面按方案分别给出网格划分、变形网格与四类云图。三种网格的图各自独立导出，可直观对比网格形态与结果差异。

3.1 四边形四结点单元（水平方向节点数：10，竖直方向节点数：5）

表3.2 四边形四结点单元自由端中点位移（网格大小10×5）

分析项目理论解有限元解相对误差(%)
自由端中点水平位移(m)1.31578947×10−31.31578947\times10^{-3}6.47050315×10−46.47050315\times10^{-4}50.824250.8242
自由端中点竖向位移(m)−1.30921053×10−2-1.30921053\times10^{-2}−1.15984396×10−2-1.15984396\times10^{-2}11.408911.4089
图3.1 四边形四结点单元原始网格与完整标注（网格大小10×5）

图3.1 四边形四结点单元原始网格与完整标注（网格大小10×5）

图3.2 四边形四结点单元变形后网格（网格大小10×5，位移放大10倍）

图3.2 四边形四结点单元变形后网格（网格大小10×5，位移放大10倍）

图3.3 四边形四结点单元u_x位移云图（网格大小10×5）

图3.3 四边形四结点单元u_x位移云图（网格大小10×5）

图3.4 四边形四结点单元u_y位移云图（网格大小10×5）

图3.4 四边形四结点单元u_y位移云图（网格大小10×5）

图3.5 四边形四结点单元σ_x应力云图（网格大小10×5）

图3.5 四边形四结点单元σ_x应力云图（网格大小10×5）

图3.6 四边形四结点单元τ_xy应力云图（网格大小10×5）

图3.6 四边形四结点单元τ_xy应力云图（网格大小10×5）

3.2 四边形四结点单元（水平方向节点数：20，竖直方向节点数：10）

表3.3 四边形四结点单元自由端中点位移（网格大小20×10）

分析项目理论解有限元解相对误差(%)
自由端中点水平位移(m)1.31578947×10−31.31578947\times10^{-3}6.47559553×10−46.47559553\times10^{-4}50.785550.7855
自由端中点竖向位移(m)−1.30921053×10−02-1.30921053\times10^{-02}−1.27849412×10−02-1.27849412\times10^{-02}2.34622.3462
图3.7 四边形四结点单元原始网格与完整标注（网格大小20×10）

图3.7 四边形四结点单元原始网格与完整标注（网格大小20×10）

图3.8 四边形四结点单元变形后网格（网格大小20×10，位移放大10倍）

图3.8 四边形四结点单元变形后网格（网格大小20×10，位移放大10倍）

图3.9 四边形四结点单元u_x位移云图（网格大小20×10）

图3.9 四边形四结点单元u_x位移云图（网格大小20×10）

图3.10 四边形四结点单元u_y位移云图（网格大小20×10）

图3.10 四边形四结点单元u_y位移云图（网格大小20×10）

图3.11 四边形四结点单元σ_x应力云图（网格大小20×10）

图3.11 四边形四结点单元σ_x应力云图（网格大小20×10）

图3.12 四边形四结点单元τ_xy应力云图（网格大小20×10）

图3.12 四边形四结点单元τ_xy应力云图（网格大小20×10）

3.3 三角形三结点单元（水平方向节点数：10，竖直方向节点数：5）

表3.4 三角形三结点单元自由端中点位移（网格大小10×5）

分析项目理论解有限元解相对误差(%)
自由端中点水平位移(m)1.31578947×10−31.31578947\times10^{-3}9.62075860×10−49.62075860\times10^{-4}26.882226.8822
自由端中点竖向位移(m)−1.30921053×10−02-1.30921053\times10^{-02}−1.17776219×10−02-1.17776219\times10^{-02}10.040310.0403
图3.13 三角形三结点单元原始网格与完整标注（网格大小10×5）

图3.13 三角形三结点单元原始网格与完整标注（网格大小10×5）

图3.14 三角形三结点单元变形后网格（网格大小10×5，位移放大10倍）

图3.14 三角形三结点单元变形后网格（网格大小10×5，位移放大10倍）

图3.15 三角形三结点单元u_x位移云图（网格大小10×5）

图3.15 三角形三结点单元u_x位移云图（网格大小10×5）

图3.16 三角形三结点单元u_y位移云图（网格大小10×5）

图3.16 三角形三结点单元u_y位移云图（网格大小10×5）

图3.17 三角形三结点单元σ_x应力云图（网格大小10×5）

图3.17 三角形三结点单元σ_x应力云图（网格大小10×5）

图3.18 三角形三结点单元τ_xy应力云图（网格大小10×5）

图3.18 三角形三结点单元τ_xy应力云图（网格大小10×5）

4 Abaqus有限元模拟

  关于此问题的 Abaqus 有限元模拟，请见 Abaqus 悬臂梁平面问题有限元分析。

5 结果分析与讨论

  把三组结果与理论解对比，有两个值得注意的现象。

  其一，竖向位移收敛良好，水平位移却始终偏差约 50%。 竖向位移的误差随网格加密从 11.41%11.41\% 降到 2.35%2.35\%，趋势正常——网格从 10×5 加密到 20×10（单元数增至 4 倍）后误差降到约 1/5，符合位移型有限元“网格越密越接近真解”的一般规律。

  但水平位移的表现完全不同：三组的误差分别是 50.82%50.82\%、50.79%50.79\%、26.88%26.88\%，其中四边形的两组无论网格如何加密都稳定在 50.8%50.8\% 附近，数值恰好是理论值的一半。误差不随网格变化，说明它不是离散误差——离散误差会随网格加密而减小，而这里几乎不动。

  由此可以给出结论：**该偏差来自理论解与计算模型对“自由端中点水平位移”这一定义本身的差异，而不是程序算错了。**理论解是按材料力学的梁理论推导的，其水平位移对应的是梁弯曲时的轴向位移分量；而有限元模型对梁段作了离散，并施加了端部固定约束，两者在该分量上的口径并不等同。由于这个差异是系统性的（与网格无关），它不会因为加密网格而消失，继续细化网格也无法改善。

  需要强调的是，这不影响程序本身的正确性判断。竖向位移的误差随网格加密从 11.41%11.41\% 收敛到 2.35%2.35\%，收敛趋势完全正常；三种网格的水平位移彼此接近（四边形两组仅差 0.03%0.03\%），说明计算结果内部是自洽的。程序可以可靠地用于不同网格方案的精度对比。

  其二，三角形单元的精度并不低于同密度的四边形单元。 同为 10×5 网格，三结点三角形单元的竖向位移误差为 10.04%10.04\%，与四边形单元的 11.41%11.41\% 相当；水平位移误差 26.88%26.88\% 反而小于四边形单元的 50.82%50.82\%。这与“四边形等参单元精度通常优于常应变三角形单元”的一般认识相反。这一点恰好印证了上面的结论：若水平位移的偏差真由单元精度决定，精度较高的四边形单元应当更接近理论值，而实际结果正相反——说明该偏差与单元类型无关，确实来自理论解与模型对分量的定义差异。

  综上：程序在竖向位移上给出可信且收敛的结果；水平位移与理论值之间存在一个固定的比例偏差（约 1/21/2），它源于理论解与有限元模型对该分量定义的差异，属系统偏差而非计算缺陷，不随网格加密改变。

]]> https://primerusse.top/2026/01/04/202601040000/ 2026-01-03T16:00:00.000Z 自编四结点等参单元，与解析解对比精度。 Python 自编四结点等参单元求解悬臂梁平面问题 2026-01-03T16:00:00.000Z Primerusse 1 问题导入

1.1 问题描述

  图示结构，a=2ma=2m，梁ABAB和梁CDCD的抗弯刚度均为E1I1=24×106N⋅m2E_1I_1=24\times 10^6N\cdot m^2。两梁用长l=5ml=5m、抗拉刚度E2A2=6×107NE_2A_2=6\times 10^7N的钢杆连接。若F=50kNF=50kN，试求梁ABAB的BB点挠度。

1.2 问题假设

  因为杆BEBE只受轴力，假设杆BEBE在结构中始终保持竖直。

  杆ABAB和杆CDCD上的各点只存在竖直方向的位移，不存在水平方向的位移。

  本文中使用的MATLAB版本是R2024b。

2 常规解析法求解问题

  在本章，我们将采用常规解析法求解问题，为以后MATLAB仿真法提供相互对照。

  设杆BEBE的轴力为ff。由题易得，杆BEBE轴向拉伸。先分别求出杆ABAB的BB点挠度和杆CDCD的EE点挠度，进而可以得到杆BEBE的长度，再与由杆BEBE的轴向拉伸公式解出的杆BEBE的长度相对照，可解出ff。

2.1 杆AB的分析及B点挠度

  杆ABAB的受力图如下。

  杆ABAB的剪力图与弯矩图如下。

  有

FsAB(x)=f(2.1)F_{sAB}(x)=f\tag{2.1}

MAB(x)=−fx+fa(2.2)M_{AB}(x)=-fx+fa\tag{2.2}

  由d2ω(x)dx2=−1EIM(x)\frac{d^2\omega(x)}{dx^2}=-\frac{1}{EI}M(x)得

d2ωAB(x)dx2=−1E1I1(−fx+fa)(2.3)\frac{d^2\omega_{AB}(x)}{dx^2}=-\frac{1}{E_1I_1}(-fx+fa)\tag{2.3}

  两边同时积分，得

θAB(x)=dωAB(x)dx=−1E1I1(−12fx2+fax)(2.4)\theta_{AB}(x)=\frac{d\omega_{AB}(x)}{dx}=-\frac{1}{E_1I_1}\left(-\frac{1}{2}fx^2+fax\right)\tag{2.4}

ωAB(x)=−1E1I1(−16fx3+12fax2)(2.5)\omega_{AB}(x)=-\frac{1}{E_1I_1}\left(-\frac{1}{6}fx^3+\frac{1}{2}fax^2\right)\tag{2.5}

  BB点的挠度，将x=ax=a代入(2.5)(2.5)式，得

ωB=ωAB(a)=−fa33E1I1(2.6)\omega_{B}=\omega_{AB}(a)=-\frac{fa^3}{3E_1I_1}\tag{2.6}

2.2 杆CD的分析及D、E点挠度

  杆CDCD的受力图如下。

  杆CDCD的剪力图与弯矩图如下。

  有

FsCD(x)={F−f,0≤x≤aF,a<x≤2a(2.7)\begin{aligned} F_{sCD}(x)= \begin{cases} F-f,\quad &0\leq x\leq a\\ F,\quad &a<x\leq 2a \end{cases}\end{aligned}\tag{2.7}

MCD(x)={−(F−f)x+(2F−f)a,0≤x≤a−Fx+2Fa,a<x≤2a(2.8)\begin{aligned} M_{CD}(x)= \begin{cases} -(F-f)x+(2F-f)a,\quad &0\leq x\leq a\\ -Fx+2Fa,\quad &a<x\leq 2a \end{cases}\end{aligned}\tag{2.8}

  当0≤x≤a\pmb{0\leq x\leq a}时，

FsCD(x)=F−f(2.9)F_{sCD}(x)=F-f\tag{2.9}

MCD(x)=−(F−f)x+(2F−f)a(2.10)M_{CD}(x)=-(F-f)x+(2F-f)a\tag{2.10}

  由d2ω(x)dx2=−1EIM(x)\frac{d^2\omega(x)}{dx^2}=-\frac{1}{EI}M(x)得

d2ωCD(x)dx2=−1E1I1[−(F−f)x+(2F−f)a](2.11)\frac{d^2\omega_{CD}(x)}{dx^2}=-\frac{1}{E_1I_1}[-(F-f)x+(2F-f)a]\tag{2.11}

  两边同时积分，得

θCD(x)=dωCD(x)dx=−1E1I1[−12(F−f)x2+(2F−f)ax](2.12)\theta_{CD}(x)=\frac{d\omega_{CD}(x)}{dx}=-\frac{1}{E_1I_1}\left[-\frac{1}{2}(F-f)x^2+(2F-f)ax\right]\tag{2.12}

ωCD(x)=−1E1I1[−16(F−f)x3+12(2F−f)ax2](2.13)\omega_{CD}(x)=-\frac{1}{E_1I_1}\left[-\frac{1}{6}(F-f)x^3+\frac{1}{2}(2F-f)ax^2\right]\tag{2.13}

  EE点的转角和挠度，将x=ax=a代入(2.12)(2.12)式和(2.13)(2.13)式，得

θE=θCD(a)=−1E1I1(32F−12f)a2(2.14)\theta_{E}=\theta_{CD}(a)=-\frac{1}{E_1I_1}\left(\frac{3}{2}F-\frac{1}{2}f\right)a^2\tag{2.14}

ωE=ωCD(a)=−1E1I1(56F−13f)a3(2.15)\omega_{E}=\omega_{CD}(a)=-\frac{1}{E_1I_1}\left(\frac{5}{6}F-\frac{1}{3}f\right)a^3\tag{2.15}

  当a<x≤2a\pmb{a<x\leq 2a}时，

FsCD(x)=F(2.16)F_{sCD}(x)=F\tag{2.16}

MCD(x)=−Fx+2Fa(2.17)M_{CD}(x)=-Fx+2Fa\tag{2.17}

  由d2ω(x)dx2=−1EIM(x)\frac{d^2\omega(x)}{dx^2}=-\frac{1}{EI}M(x)得

d2ωCD(x)dx2=−1E1I1(−Fx+2Fa)(2.18)\frac{d^2\omega_{CD}(x)}{dx^2}=-\frac{1}{E_1I_1}(-Fx+2Fa)\tag{2.18}

  两边同时积分，得

θCD(x)=dωCD(x)dx=−1E1I1[−12Fx2+2Fax−12fa2](2.19)\theta_{CD}(x)=\frac{d\omega_{CD}(x)}{dx}=-\frac{1}{E_1I_1}\left[-\frac{1}{2}Fx^2+2Fax-\frac{1}{2}fa^2\right]\tag{2.19}

ωCD(x)=−1E1I1[−16Fx3+Fax2−12fa2x+16fa3](2.20)\omega_{CD}(x)=-\frac{1}{E_1I_1}\left[-\frac{1}{6}Fx^3+Fax^2-\frac{1}{2}fa^2x+\frac{1}{6}fa^3\right]\tag{2.20}

2.3 杆BE的分析

  杆BEBE的轴力为ff，由Δl=FNlEA\Delta l=\frac{F_Nl}{EA}得

ΔlBE=flE2A2(2.21)\Delta l_{BE}=\frac{fl}{E_2A_2}\tag{2.21}

  另外，

ΔlBE=ωB−ωE=−fa33E1I1+1E1I1(56F−13f)a3=1E1I1(56F−23f)a3(2.22)\begin{aligned} \Delta l_{BE}=&\omega_{B}-\omega_{E}=-\frac{fa^3}{3E_1I_1}+\frac{1}{E_1I_1}\left(\frac{5}{6}F-\frac{1}{3}f\right)a^3\\ =&\frac{1}{E_1I_1}\left(\frac{5}{6}F-\frac{2}{3}f\right)a^3\end{aligned}\tag{2.22}

  联立(2.21)(2.21)式和(2.22)(2.22)式，得

f=5E2A2Fa36E1I1l+4E2A2a3(2.23)f=\frac{5E_2A_2Fa^3}{6E_1I_1l+4E_2A_2a^3}\tag{2.23}

2.4 B点的挠度

  将(2.23)(2.23)式代入(2.6)(2.6)式，得

ωB=−5E2A2Fa63E1I1(6E1I1l+4E2A2a3)=−1198≈−0.005051(2.24)\omega_{B}=-\frac{5E_2A_2Fa^6}{3E_1I_1(6E_1I_1l+4E_2A_2a^3)}=-\frac{1}{198}\approx-0.005051\tag{2.24}

3 MATLAB仿真法求解问题

3.1 自由端受集中载荷的悬臂梁仿真思路

  如图，有一悬臂梁，其自由端受一集中载荷FF。

  剪力图与弯矩图如下。

  将梁划分为若干长度为dxdx的微元。

  分析从右往左数第一个（最右端）微元的受力状态。

  其中，Fs1F_{s1}和M1M_1是从右往左数第二个微元作用在它上的，为维持平衡，Fs1F_{s1}和M1M_1需满足

{Fs1=FM1=Fdx(3.1)\begin{aligned} \begin{cases} F_{s1}=F\\ M_1=Fdx \end{cases}\end{aligned}\tag{3.1}

  由剪力图与弯矩图可知，这一点所受到的剪力和弯矩为

{Fs1′=FM1′=0(3.2)\begin{aligned} \begin{cases} F_{s1}'=F\\ M_1'=0 \end{cases}\end{aligned}\tag{3.2}

  分析从右往左数第二个微元的受力状态。

  其中，Fs2F_{s2}和M2M_2是从右往左数第三个微元作用在它上的，为维持平衡，Fs2F_{s2}和M2M_2需满足

{Fs2=FM2=2Fdx(3.3)\begin{aligned} \begin{cases} F_{s2}=F\\ M_2=2Fdx \end{cases}\end{aligned}\tag{3.3}

  由剪力图与弯矩图可知，这一点所受到的剪力和弯矩为

{Fs2′=F=Fs1M2′=Fdx=M1(3.4)\begin{aligned} \begin{cases} F_{s2}'=F=F_{s1}\\ M_2'=Fdx=M_1 \end{cases}\end{aligned}\tag{3.4}

  由此可以得出梁上某一点受到的剪力和弯矩，取决于这一点处微元右侧面所受的力与力矩，大小与其相等，方向与其相反。

  弯矩是通过剪力在相邻微元中传递的，宏观上来看，是此微元右侧各点所受到的剪力产生微小力矩（长度为dx\pmb{dx}）的总和。

3.2 算法思路

  设微元长度为dxdx，长度为a的范围内微元数为nxnx。则可以建立一个1×nx1\times nx的矩阵，来描述杆ABAB各微元处的剪力，称为剪力矩阵。同样，可以建立一个1×2nx1\times 2nx的杆CDCD的剪力矩阵。用相同的方法，建立弯矩矩阵和挠度矩阵来描述杆ABAB和杆CDCD各微元处的弯矩和挠度。

  这三种矩阵之间是存在相互联系的。对于剪力矩阵，在除了BB点和EE点之外的所有的点，它的剪力等于右侧相邻点的剪力，由此，可以根据已知的自由端的力，迭代出每一点的剪力。对于弯矩矩阵，每一点弯矩的值，等于右侧各点所受到的剪力产生微小力矩（长度为dxdx）的总和。对于挠度矩阵，每一点挠度函数二阶导数的值，等于这一点弯矩的值乘以−1EI-\frac{1}{EI}。再由辛普森法来求出这一点的挠度的值。

  另外还有边界条件。由第2章剪力图可知，杆ABAB与杆CECE同一竖直方向上的两点，剪力和为FF。

  我们不知道杆BEBE的轴力，可以假定一个初始值。判断这个轴力值合不合适的标准是：由杆AB\pmb{AB}和杆CD\pmb{CD}的两个挠度矩阵，所确定的B\pmb{B}点处挠度值ωB\pmb{\omega_{B}}和E\pmb{E}点处挠度值ωE\pmb{\omega_{E}}，计算两者的差值ωB−ωE\pmb{\omega_{B}-\omega_{E}}。由轴向拉伸公式所确定的杆BE\pmb{BE}的伸长量ΔlBE\pmb{\Delta l_{BE}}（杆BE\pmb{BE}轴力与杆AB\pmb{AB}剪力相同）。应有：

ΔlBE=ωB−ωE(3.5)\pmb{\Delta l_{BE}=\omega_{B}-\omega_{E}\tag{3.5}}

  如果假设的轴力不合适，我们可以对这个值进行微量的增加，再校验。重复以上，直到轴力合适。

  由合适的轴力可以迭代出杆ABAB的挠度矩阵，进而得到BB点处的挠度。

  具体的MATLAB源代码及其运行结果见下。

  源代码已上传Github，可以访问链接下载源代码。

3.3 MATLAB源代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
clc;
clear;
close all;
format short
%% 参数设置
a = 2;
l = 5;
F = 50 * 10 ^ 3;
E1I1 = 24 * 10 ^ 6;
E2A2 = 6 * 10 ^ 7;
%% 解析解计算
analytical_solution = - (5 * E2A2 * F * a ^ 6) / (3 * E1I1) / (6 * E1I1 * l + 4 * E2A2 * a ^ 3);
%% 离散化参数
dx = 0.005;
% 微元长度
df = 0.5;
% 迭代增加轴力的步长
nx = a / dx;
% 长度为a的微元数
%% 初始化边界条件
F_AB_end = df;
% 杆AB末端剪力初始猜测值
F_CD_end = F;
% 杆CD末端集中力
%% 迭代模拟
for i = 1 : 10 ^ 10
    % 末端尽量大，使充分迭代
    [F_AB, M_AB, W_AB, F_CD, M_CD, W_CD, diff_w, diff_L, w_B] = sim(F_AB_end, F_CD_end, l, F, E1I1, E2A2, dx, nx);
    if mod(i, 100) == 0
        % 进度条
        clc;
        disp('程序运行进度:')
        a = w_B / analytical_solution * 100;
        s = ['[', repmat('*', 1, floor(a / 4)), repmat('-', 1, 50 floor(a / 4)), ']'];
        fprintf('%s', s)
        fprintf('%2.2f%%', a)
    end
    if abs(diff_w - diff_L) <= 0.000001
        % diff_w与diff_L近似相等
        clc;
        fprintf('算法值为: %.4f\n', w_B);
        fprintf('解析值为: %.4f\n', analytical_solution);
        fprintf('算法值与解析值相对误差为: %.4f%%\n', abs((w_B - analytical_solution) / analytical_solution) * 100);
        disp('杆AB的挠度矩阵:')
        disp(W_AB)
        disp('杆CD的挠度矩阵:')
        disp(W_CD)
        break
    end
    F_AB_end = F_AB_end + df;
end
%% 定义模拟函数
function [F_AB, M_AB, W_AB, F_CD, M_CD, W_CD, diff_w, diff_L, w_B] = sim(F_AB_end, F_CD_end, l, F, E1I1, E2A2, dx, nx)
    % 初始化杆件状态
    % 杆AB的剪力、弯矩、挠度矩阵
    F_AB = zeros(1, nx);
    M_AB = zeros(1, nx);
    W_AB = zeros(1, nx);
    % 杆CD的剪力、弯矩、挠度矩阵
    F_CD = zeros(1, 2 * nx);
    M_CD = zeros(1, 2 * nx);
    W_CD = zeros(1, 2 * nx);
    % 初始化边界条件
    F_AB(end) = F_AB_end;
    F_CD(end) = F_CD_end;
    % 剪力的传递
    % 杆AB
    for i = nx-1 : -1 : 1
        F_AB(i) = F_AB(i + 1);
    end
    % 杆CD
    for i = 2 * nx - 1 : - 1 : nx + 1
        F_CD(i) = F_CD(i + 1);
    end
    for i = nx - 1 : - 1 : 1
        F_CD(i) = F - F_AB(i);
    end
    % 弯矩的传递
    % 杆AB
    for i = nx - 1 : - 1 : 1
        M_AB(i) = sum(F_AB(i + 1 : end) * dx);
    end
    % 杆CD
    for i = 2 * nx - 1 : - 1 : 1
        M_CD(i) = sum(F_CD(i + 1 : end) * dx);
    end
    % 挠度的传递
    % 挠度的二阶导数
    W2_AB = - M_AB / E1I1;
    W2_CD = - M_CD / E1I1;
    % 第一次积分，辛普森法数值积分
    slope_AB = simpson_integrate(W2_AB, dx);
    slope_CD = simpson_integrate(W2_CD, dx);
    % 第二次积分，辛普森法数值积分
    W_AB = simpson_integrate(slope_AB, dx);
    W_CD = simpson_integrate(slope_CD, dx);
    % 输出结果
    diff_w = W_AB(nx) - W_CD(nx);
    diff_L = F_AB(nx) * l / E2A2;
    w_B = W_AB(nx);
end
%% 辛普森法数值积分
function y = simpson_integrate(f, h)
    % 输入:
    % f - 导数在等距点上的值向量 [f0, f1, f2, ..., fN]
    % h - 采样步长
    % 输出:
    % y - 原函数在对应点上的值向量 [y0, y1, y2, ..., yN]
    N = length(f) - 1; % 采样点数-1
    y = zeros(1, N + 1); % 存储原函数y的值
    % 初始条件
    y(1) = 0;
    % 逐点积分计算原函数y
    for k = 1 : N
        % 计算原函数y(k+1)
        if mod(k, 2) == 1
            % 奇步长: 梯形法则
            y(k + 1) = y(k) + (h / 2) * (f(k) + f(k + 1));
        else
            % 偶步长: 辛普森法则
            y(k + 1) = y(k - 1) + (h / 3) * (f(k - 1) + 4 * f(k) + f(k + 1));
        end
    end
end

3.4 MATLAB代码运行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
算法值为: -0.0050

解析值为: -0.0051

算法值与解析值相对误差为: 0.8236%

杆AB的挠度矩阵:

  列 1 至 6

         0   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 7 至 12

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 13 至 18

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 19 至 24

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 25 至 30

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 31 至 36

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0001   -0.0001

  列 37 至 42

   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001

  列 43 至 48

   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001

  列 49 至 54

   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001

  列 55 至 60

   -0.0001   -0.0001   -0.0001   -0.0001   -0.0002   -0.0002

  列 61 至 66

   -0.0002   -0.0002   -0.0002   -0.0002   -0.0002   -0.0002

  列 67 至 72

   -0.0002   -0.0002   -0.0002   -0.0002   -0.0002   -0.0002

  列 73 至 78

   -0.0002   -0.0002   -0.0002   -0.0002   -0.0003   -0.0003

  列 79 至 84

   -0.0003   -0.0003   -0.0003   -0.0003   -0.0003   -0.0003

  列 85 至 90

   -0.0003   -0.0003   -0.0003   -0.0003   -0.0003   -0.0003

  列 91 至 96

   -0.0004   -0.0004   -0.0004   -0.0004   -0.0004   -0.0004

  列 97 至 102

   -0.0004   -0.0004   -0.0004   -0.0004   -0.0004   -0.0004

  列 103 至 108

   -0.0004   -0.0005   -0.0005   -0.0005   -0.0005   -0.0005

  列 109 至 114

   -0.0005   -0.0005   -0.0005   -0.0005   -0.0005   -0.0005

  列 115 至 120

   -0.0006   -0.0006   -0.0006   -0.0006   -0.0006   -0.0006

  列 121 至 126

   -0.0006   -0.0006   -0.0006   -0.0006   -0.0007   -0.0007

  列 127 至 132

   -0.0007   -0.0007   -0.0007   -0.0007   -0.0007   -0.0007

  列 133 至 138

   -0.0007   -0.0007   -0.0008   -0.0008   -0.0008   -0.0008

  列 139 至 144

   -0.0008   -0.0008   -0.0008   -0.0008   -0.0008   -0.0008

  列 145 至 150

   -0.0009   -0.0009   -0.0009   -0.0009   -0.0009   -0.0009

  列 151 至 156

   -0.0009   -0.0009   -0.0010   -0.0010   -0.0010   -0.0010

  列 157 至 162

   -0.0010   -0.0010   -0.0010   -0.0010   -0.0010   -0.0011

  列 163 至 168

   -0.0011   -0.0011   -0.0011   -0.0011   -0.0011   -0.0011

  列 169 至 174

   -0.0011   -0.0012   -0.0012   -0.0012   -0.0012   -0.0012

  列 175 至 180

   -0.0012   -0.0012   -0.0012   -0.0013   -0.0013   -0.0013

  列 181 至 186

   -0.0013   -0.0013   -0.0013   -0.0013   -0.0014   -0.0014

  列 187 至 192

   -0.0014   -0.0014   -0.0014   -0.0014   -0.0014   -0.0014

  列 193 至 198

   -0.0015   -0.0015   -0.0015   -0.0015   -0.0015   -0.0015

  列 199 至 204

   -0.0015   -0.0016   -0.0016   -0.0016   -0.0016   -0.0016

  列 205 至 210

   -0.0016   -0.0016   -0.0017   -0.0017   -0.0017   -0.0017

  列 211 至 216

   -0.0017   -0.0017   -0.0017   -0.0018   -0.0018   -0.0018

  列 217 至 222

   -0.0018   -0.0018   -0.0018   -0.0018   -0.0019   -0.0019

  列 223 至 228

   -0.0019   -0.0019   -0.0019   -0.0019   -0.0020   -0.0020

  列 229 至 234

   -0.0020   -0.0020   -0.0020   -0.0020   -0.0020   -0.0021

  列 235 至 240

   -0.0021   -0.0021   -0.0021   -0.0021   -0.0021   -0.0022

  列 241 至 246

   -0.0022   -0.0022   -0.0022   -0.0022   -0.0022   -0.0023

  列 247 至 252

   -0.0023   -0.0023   -0.0023   -0.0023   -0.0023   -0.0023

  列 253 至 258

   -0.0024   -0.0024   -0.0024   -0.0024   -0.0024   -0.0024

  列 259 至 264

   -0.0025   -0.0025   -0.0025   -0.0025   -0.0025   -0.0025

  列 265 至 270

   -0.0026   -0.0026   -0.0026   -0.0026   -0.0026   -0.0026

  列 271 至 276

   -0.0027   -0.0027   -0.0027   -0.0027   -0.0027   -0.0027

  列 277 至 282

   -0.0028   -0.0028   -0.0028   -0.0028   -0.0028   -0.0029

  列 283 至 288

   -0.0029   -0.0029   -0.0029   -0.0029   -0.0029   -0.0030

  列 289 至 294

   -0.0030   -0.0030   -0.0030   -0.0030   -0.0030   -0.0031

  列 295 至 300

   -0.0031   -0.0031   -0.0031   -0.0031   -0.0031   -0.0032

  列 301 至 306

   -0.0032   -0.0032   -0.0032   -0.0032   -0.0033   -0.0033

  列 307 至 312

   -0.0033   -0.0033   -0.0033   -0.0033   -0.0034   -0.0034

  列 313 至 318

   -0.0034   -0.0034   -0.0034   -0.0035   -0.0035   -0.0035

  列 319 至 324

   -0.0035   -0.0035   -0.0035   -0.0036   -0.0036   -0.0036

  列 325 至 330

   -0.0036   -0.0036   -0.0036   -0.0037   -0.0037   -0.0037

  列 331 至 336

   -0.0037   -0.0037   -0.0038   -0.0038   -0.0038   -0.0038

  列 337 至 342

   -0.0038   -0.0039   -0.0039   -0.0039   -0.0039   -0.0039

  列 343 至 348

   -0.0039   -0.0040   -0.0040   -0.0040   -0.0040   -0.0040

  列 349 至 354

   -0.0041   -0.0041   -0.0041   -0.0041   -0.0041   -0.0041

  列 355 至 360

   -0.0042   -0.0042   -0.0042   -0.0042   -0.0042   -0.0043

  列 361 至 366

   -0.0043   -0.0043   -0.0043   -0.0043   -0.0044   -0.0044

  列 367 至 372

   -0.0044   -0.0044   -0.0044   -0.0044   -0.0045   -0.0045

  列 373 至 378

   -0.0045   -0.0045   -0.0045   -0.0046   -0.0046   -0.0046

  列 379 至 384

   -0.0046   -0.0046   -0.0047   -0.0047   -0.0047   -0.0047

  列 385 至 390

   -0.0047   -0.0047   -0.0048   -0.0048   -0.0048   -0.0048

  列 391 至 396

   -0.0048   -0.0049   -0.0049   -0.0049   -0.0049   -0.0049

  列 397 至 400

   -0.0050   -0.0050   -0.0050   -0.0050

杆CD的挠度矩阵:

  列 1 至 6

         0   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 7 至 12

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 13 至 18

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 19 至 24

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 25 至 30

   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000   -0.0000

  列 31 至 36

   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001

  列 37 至 42

   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001

  列 43 至 48

   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001   -0.0001

  列 49 至 54

   -0.0001   -0.0001   -0.0001   -0.0001   -0.0002   -0.0002

  列 55 至 60

   -0.0002   -0.0002   -0.0002   -0.0002   -0.0002   -0.0002

  列 61 至 66

   -0.0002   -0.0002   -0.0002   -0.0002   -0.0002   -0.0002

  列 67 至 72

   -0.0002   -0.0003   -0.0003   -0.0003   -0.0003   -0.0003

  列 73 至 78

   -0.0003   -0.0003   -0.0003   -0.0003   -0.0003   -0.0003

  列 79 至 84

   -0.0003   -0.0004   -0.0004   -0.0004   -0.0004   -0.0004

  列 85 至 90

   -0.0004   -0.0004   -0.0004   -0.0004   -0.0004   -0.0004

  列 91 至 96

   -0.0005   -0.0005   -0.0005   -0.0005   -0.0005   -0.0005

  列 97 至 102

   -0.0005   -0.0005   -0.0005   -0.0006   -0.0006   -0.0006

  列 103 至 108

   -0.0006   -0.0006   -0.0006   -0.0006   -0.0006   -0.0006

  列 109 至 114

   -0.0007   -0.0007   -0.0007   -0.0007   -0.0007   -0.0007

  列 115 至 120

   -0.0007   -0.0007   -0.0008   -0.0008   -0.0008   -0.0008

  列 121 至 126

   -0.0008   -0.0008   -0.0008   -0.0009   -0.0009   -0.0009

  列 127 至 132

   -0.0009   -0.0009   -0.0009   -0.0009   -0.0010   -0.0010

  列 133 至 138

   -0.0010   -0.0010   -0.0010   -0.0010   -0.0010   -0.0011

  列 139 至 144

   -0.0011   -0.0011   -0.0011   -0.0011   -0.0011   -0.0012

  列 145 至 150

   -0.0012   -0.0012   -0.0012   -0.0012   -0.0012   -0.0012

  列 151 至 156

   -0.0013   -0.0013   -0.0013   -0.0013   -0.0013   -0.0014

  列 157 至 162

   -0.0014   -0.0014   -0.0014   -0.0014   -0.0014   -0.0015

  列 163 至 168

   -0.0015   -0.0015   -0.0015   -0.0015   -0.0015   -0.0016

  列 169 至 174

   -0.0016   -0.0016   -0.0016   -0.0016   -0.0017   -0.0017

  列 175 至 180

   -0.0017   -0.0017   -0.0017   -0.0018   -0.0018   -0.0018

  列 181 至 186

   -0.0018   -0.0018   -0.0019   -0.0019   -0.0019   -0.0019

  列 187 至 192

   -0.0019   -0.0020   -0.0020   -0.0020   -0.0020   -0.0020

  列 193 至 198

   -0.0021   -0.0021   -0.0021   -0.0021   -0.0022   -0.0022

  列 199 至 204

   -0.0022   -0.0022   -0.0022   -0.0023   -0.0023   -0.0023

  列 205 至 210

   -0.0023   -0.0024   -0.0024   -0.0024   -0.0024   -0.0024

  列 211 至 216

   -0.0025   -0.0025   -0.0025   -0.0025   -0.0026   -0.0026

  列 217 至 222

   -0.0026   -0.0026   -0.0027   -0.0027   -0.0027   -0.0027

  列 223 至 228

   -0.0028   -0.0028   -0.0028   -0.0028   -0.0029   -0.0029

  列 229 至 234

   -0.0029   -0.0029   -0.0030   -0.0030   -0.0030   -0.0030

  列 235 至 240

   -0.0031   -0.0031   -0.0031   -0.0031   -0.0032   -0.0032

  列 241 至 246

   -0.0032   -0.0032   -0.0033   -0.0033   -0.0033   -0.0034

  列 247 至 252

   -0.0034   -0.0034   -0.0034   -0.0035   -0.0035   -0.0035

  列 253 至 258

   -0.0035   -0.0036   -0.0036   -0.0036   -0.0037   -0.0037

  列 259 至 264

   -0.0037   -0.0037   -0.0038   -0.0038   -0.0038   -0.0039

  列 265 至 270

   -0.0039   -0.0039   -0.0039   -0.0040   -0.0040   -0.0040

  列 271 至 276

   -0.0041   -0.0041   -0.0041   -0.0042   -0.0042   -0.0042

  列 277 至 282

   -0.0042   -0.0043   -0.0043   -0.0043   -0.0044   -0.0044

  列 283 至 288

   -0.0044   -0.0045   -0.0045   -0.0045   -0.0046   -0.0046

  列 289 至 294

   -0.0046   -0.0047   -0.0047   -0.0047   -0.0047   -0.0048

  列 295 至 300

   -0.0048   -0.0048   -0.0049   -0.0049   -0.0049   -0.0050

  列 301 至 306

   -0.0050   -0.0050   -0.0051   -0.0051   -0.0051   -0.0052

  列 307 至 312

   -0.0052   -0.0052   -0.0053   -0.0053   -0.0053   -0.0054

  列 313 至 318

   -0.0054   -0.0054   -0.0055   -0.0055   -0.0055   -0.0056

  列 319 至 324

   -0.0056   -0.0057   -0.0057   -0.0057   -0.0058   -0.0058

  列 325 至 330

   -0.0058   -0.0059   -0.0059   -0.0059   -0.0060   -0.0060

  列 331 至 336

   -0.0060   -0.0061   -0.0061   -0.0062   -0.0062   -0.0062

  列 337 至 342

   -0.0063   -0.0063   -0.0063   -0.0064   -0.0064   -0.0065

  列 343 至 348

   -0.0065   -0.0065   -0.0066   -0.0066   -0.0066   -0.0067

  列 349 至 354

   -0.0067   -0.0068   -0.0068   -0.0068   -0.0069   -0.0069

  列 355 至 360

   -0.0069   -0.0070   -0.0070   -0.0071   -0.0071   -0.0071

  列 361 至 366

   -0.0072   -0.0072   -0.0073   -0.0073   -0.0073   -0.0074

  列 367 至 372

   -0.0074   -0.0075   -0.0075   -0.0075   -0.0076   -0.0076

  列 373 至 378

   -0.0077   -0.0077   -0.0077   -0.0078   -0.0078   -0.0079

  列 379 至 384

   -0.0079   -0.0079   -0.0080   -0.0080   -0.0081   -0.0081

  列 385 至 390

   -0.0082   -0.0082   -0.0082   -0.0083   -0.0083   -0.0084

  列 391 至 396

   -0.0084   -0.0085   -0.0085   -0.0085   -0.0086   -0.0086

  列 397 至 402

   -0.0087   -0.0087   -0.0088   -0.0088   -0.0088   -0.0089

  列 403 至 408

   -0.0089   -0.0090   -0.0090   -0.0091   -0.0091   -0.0091

  列 409 至 414

   -0.0092   -0.0092   -0.0093   -0.0093   -0.0094   -0.0094

  列 415 至 420

   -0.0095   -0.0095   -0.0095   -0.0096   -0.0096   -0.0097

  列 421 至 426

   -0.0097   -0.0098   -0.0098   -0.0099   -0.0099   -0.0100

  列 427 至 432

   -0.0100   -0.0101   -0.0101   -0.0101   -0.0102   -0.0102

  列 433 至 438

   -0.0103   -0.0103   -0.0104   -0.0104   -0.0105   -0.0105

  列 439 至 444

   -0.0106   -0.0106   -0.0107   -0.0107   -0.0108   -0.0108

  列 445 至 450

   -0.0109   -0.0109   -0.0109   -0.0110   -0.0110   -0.0111

  列 451 至 456

   -0.0111   -0.0112   -0.0112   -0.0113   -0.0113   -0.0114

  列 457 至 462

   -0.0114   -0.0115   -0.0115   -0.0116   -0.0116   -0.0117

  列 463 至 468

   -0.0117   -0.0118   -0.0118   -0.0119   -0.0119   -0.0120

  列 469 至 474

   -0.0120   -0.0121   -0.0121   -0.0122   -0.0122   -0.0123

  列 475 至 480

   -0.0123   -0.0124   -0.0124   -0.0125   -0.0125   -0.0126

  列 481 至 486

   -0.0126   -0.0127   -0.0127   -0.0128   -0.0128   -0.0129

  列 487 至 492

   -0.0129   -0.0130   -0.0130   -0.0131   -0.0131   -0.0132

  列 493 至 498

   -0.0133   -0.0133   -0.0134   -0.0134   -0.0135   -0.0135

  列 499 至 504

   -0.0136   -0.0136   -0.0137   -0.0137   -0.0138   -0.0138

  列 505 至 510

   -0.0139   -0.0139   -0.0140   -0.0140   -0.0141   -0.0141

  列 511 至 516

   -0.0142   -0.0143   -0.0143   -0.0144   -0.0144   -0.0145

  列 517 至 522

   -0.0145   -0.0146   -0.0146   -0.0147   -0.0147   -0.0148

  列 523 至 528

   -0.0148   -0.0149   -0.0150   -0.0150   -0.0151   -0.0151

  列 529 至 534

   -0.0152   -0.0152   -0.0153   -0.0153   -0.0154   -0.0154

  列 535 至 540

   -0.0155   -0.0156   -0.0156   -0.0157   -0.0157   -0.0158

  列 541 至 546

   -0.0158   -0.0159   -0.0159   -0.0160   -0.0161   -0.0161

  列 547 至 552

   -0.0162   -0.0162   -0.0163   -0.0163   -0.0164   -0.0165

  列 553 至 558

   -0.0165   -0.0166   -0.0166   -0.0167   -0.0167   -0.0168

  列 559 至 564

   -0.0168   -0.0169   -0.0170   -0.0170   -0.0171   -0.0171

  列 565 至 570

   -0.0172   -0.0172   -0.0173   -0.0174   -0.0174   -0.0175

  列 571 至 576

   -0.0175   -0.0176   -0.0176   -0.0177   -0.0178   -0.0178

  列 577 至 582

   -0.0179   -0.0179   -0.0180   -0.0181   -0.0181   -0.0182

  列 583 至 588

   -0.0182   -0.0183   -0.0183   -0.0184   -0.0185   -0.0185

  列 589 至 594

   -0.0186   -0.0186   -0.0187   -0.0188   -0.0188   -0.0189

  列 595 至 600

   -0.0189   -0.0190   -0.0190   -0.0191   -0.0192   -0.0192

  列 601 至 606

   -0.0193   -0.0193   -0.0194   -0.0195   -0.0195   -0.0196

  列 607 至 612

   -0.0196   -0.0197   -0.0198   -0.0198   -0.0199   -0.0199

  列 613 至 618

   -0.0200   -0.0201   -0.0201   -0.0202   -0.0202   -0.0203

  列 619 至 624

   -0.0204   -0.0204   -0.0205   -0.0205   -0.0206   -0.0207

  列 625 至 630

   -0.0207   -0.0208   -0.0208   -0.0209   -0.0210   -0.0210

  列 631 至 636

   -0.0211   -0.0211   -0.0212   -0.0213   -0.0213   -0.0214

  列 637 至 642

   -0.0214   -0.0215   -0.0216   -0.0216   -0.0217   -0.0217

  列 643 至 648

   -0.0218   -0.0219   -0.0219   -0.0220   -0.0221   -0.0221

  列 649 至 654

   -0.0222   -0.0222   -0.0223   -0.0224   -0.0224   -0.0225

  列 655 至 660

   -0.0225   -0.0226   -0.0227   -0.0227   -0.0228   -0.0229

  列 661 至 666

   -0.0229   -0.0230   -0.0230   -0.0231   -0.0232   -0.0232

  列 667 至 672

   -0.0233   -0.0233   -0.0234   -0.0235   -0.0235   -0.0236

  列 673 至 678

   -0.0237   -0.0237   -0.0238   -0.0238   -0.0239   -0.0240

  列 679 至 684

   -0.0240   -0.0241   -0.0242   -0.0242   -0.0243   -0.0243

  列 685 至 690

   -0.0244   -0.0245   -0.0245   -0.0246   -0.0247   -0.0247

  列 691 至 696

   -0.0248   -0.0248   -0.0249   -0.0250   -0.0250   -0.0251

  列 697 至 702

   -0.0252   -0.0252   -0.0253   -0.0253   -0.0254   -0.0255

  列 703 至 708

   -0.0255   -0.0256   -0.0257   -0.0257   -0.0258   -0.0259

  列 709 至 714

   -0.0259   -0.0260   -0.0260   -0.0261   -0.0262   -0.0262

  列 715 至 720

   -0.0263   -0.0264   -0.0264   -0.0265   -0.0265   -0.0266

  列 721 至 726

   -0.0267   -0.0267   -0.0268   -0.0269   -0.0269   -0.0270

  列 727 至 732

   -0.0271   -0.0271   -0.0272   -0.0272   -0.0273   -0.0274

  列 733 至 738

   -0.0274   -0.0275   -0.0276   -0.0276   -0.0277   -0.0278

  列 739 至 744

   -0.0278   -0.0279   -0.0279   -0.0280   -0.0281   -0.0281

  列 745 至 750

   -0.0282   -0.0283   -0.0283   -0.0284   -0.0285   -0.0285

  列 751 至 756

   -0.0286   -0.0287   -0.0287   -0.0288   -0.0288   -0.0289

  列 757 至 762

   -0.0290   -0.0290   -0.0291   -0.0292   -0.0292   -0.0293

  列 763 至 768

   -0.0294   -0.0294   -0.0295   -0.0295   -0.0296   -0.0297

  列 769 至 774

   -0.0297   -0.0298   -0.0299   -0.0299   -0.0300   -0.0301

  列 775 至 780

   -0.0301   -0.0302   -0.0303   -0.0303   -0.0304   -0.0304

  列 781 至 786

   -0.0305   -0.0306   -0.0306   -0.0307   -0.0308   -0.0308

  列 787 至 792

   -0.0309   -0.0310   -0.0310   -0.0311   -0.0312   -0.0312

  列 793 至 798

   -0.0313   -0.0313   -0.0314   -0.0315   -0.0315   -0.0316

  列 799 至 800

   -0.0317   -0.0317

4 总结

  本文用两条独立的路径求出了同一结构的 BB 点挠度：第 2 节的解析法从挠曲线微分方程出发，分段求出杆 ABAB、CDCD 的转角与挠度表达式，再由杆 BEBE 的轴向变形协调条件联立解出轴力 ff；第 3 节的MATLAB 数值法把杆离散成微元，用迭代传递剪力、弯矩与挠度的二阶导数，以辛普森法积分求得挠度，并通过轴力迭代使钢杆变形与结构挠度相协调。

  两者的结果吻合，误差小于 1%1\%。这说明本文建立的数值流程是正确的——数值法的各个环节（微元划分、辛普森积分、轴力迭代）都没有引入显著误差。

  两种方法的特点对比：

解析法MATLAB 数值法
思路分段列挠曲线微分方程，联立边界条件离散成微元，逐段迭代传递内力与变形
精度精确解（在假设成立的前提下）与解析解误差 <1%<1\%，受微元长度 dxdx 与迭代步长 dfdf 控制
适用构件少、载荷规则的结构；公式推导量随构件数迅速增长多构件耦合、复杂边界条件；改参数即可重算
局限构件一多，手工推导极易出错结果受离散精度影响，需先验证收敛性

  本题选用 dx=0.005mdx=0.005m、df=0.5Ndf=0.5N。这样小的步长对本题规模来说余量充足，但并非越大越好——步长过小会成倍增加迭代次数，而精度提升有限。实际使用时应先做一次步长收敛性检查，再取满足精度要求的最粗步长。

致谢

  感谢房凯老师这一个学期的耐心教导！

  感谢父母与朋友在生活中无微不至的照顾！

  在我这么多朋友中，我尤其感谢远在河北某本科上学的异父异母的亲兄弟——Hana，感谢他在编程方面对我的帮助。感谢他凌晨一点半还热心地教我怎样在Github上上传文件，我的博客网站得以建成，他功不可没。

]]> https://primerusse.top/2025/06/27/202506270200/ 2025-06-26T18:00:00.000Z 解析法与 MATLAB 数值解的相互印证。 MATLAB 求解梁挠度的材料力学应用题 2025-06-26T18:00:00.000Z Primerusse 1 有限差分法理论基础

1.1 有限差分法概述

  有限差分法（Finite Difference Method，FDM）是一种求解微分方程数值解的近似方法，其主要原理是对微分方程中的微分项进行直接差分近似，从而将微分方程转化为代数方程组求解。这里的近似采取的是离散近似，使用某一点周围点的函数值近似表示该点的微分。

  有限差分法面对的对象是微分方程，包括常微分方程和偏微分方程。

  有限差分法的原理简单直接，最早由欧拉（Leonhard Euler,1707-1783）提出，他在1768年给出了一维问题的差分格式。1908年，龙格（Carl Runge,1856-1927）将差分法扩展到了二维问题。但是在那个年代，将微分方程的求解转化为大量代数方程组的求解，无疑是将一个难题转化为另一个难题，因此并未得到大量的应用。随着计算机技术的发展，快速准确地求解庞大的代数方程组成为可能，因此逐渐得到大量的应用。发展至今，有限差分法已成为一个重要的数值求解方法，在工程领域有着广泛的应用背景。

  下面将对该方法进行概述。

  本文中使用的MATLAB版本是R2024b。

1.2 有限差分法中微分的近似表示

  一般地，假设函数u(x)u(x)在求解域内连续可导，则由泰勒级数我们可以得到

u(x+h)=u(x)+hu′(x)+h22u′′(x)+...+hkk!u(k)(x)+...(1.1)u(x+h)=u(x)+hu'(x)+\frac{h^2}{2}u''(x)+...+\frac{h^k}{k!}u^{(k)}(x)+...\tag{1.1}

  基于泰勒级数并做适当的截断，我们就可以得到各阶微分的近似表达式，即“差分公式”。下面主要对一阶和二阶微分的差分公式进行讨论，更高阶的微分可以同理推导得到。

1.2.1 一阶微分的差分公式

  我们可以将(1.1)(1.1)式另写作

u(x+h)=u(x)+hu′(x)+h22u′′(x)+h36u′′′(x)+...(1.2)u(x+h)=u(x)+hu'(x)+\frac{h^2}{2}u''(x)+\frac{h^3}{6}u'''(x)+...\tag{1.2}

  对上式变形即可以得到一阶微分的向前差分公式

u′(x)=u(x+h)−u(x)h−h2u′′(x)−h26u′′′(x)−...≈u(x+h)−u(x)h(1.3)\begin{aligned} u'(x)=&\frac{u(x+h)-u(x)}{h}-\frac{h}{2}u''(x)-\frac{h^2}{6}u'''(x)-...\\ \approx&\frac{u(x+h)-u(x)}{h}\end{aligned}\tag{1.3}

  其误差项为

−h2u′′(x)−h26u′′′(x)−...−h2k−2(2k−1)!u(2k−1)(x)−h2k−1(2k)!u(2k)(x)−...(1.4)-\frac{h}{2}u''(x)-\frac{h^2}{6}u'''(x)-...-\frac{h^{2k-2}}{(2k-1)!}u^{(2k-1)}(x)-\frac{h^{2k-1}}{(2k)!}u^{(2k)}(x)-...\tag{1.4}

  将(1.3)(1.3)式中的hh用−h-h代替，则可以得到一阶微分的向后差分公式

u′(x)=u(x)−u(x−h)h+h2u′′(x)−h26u′′′(x)+...≈u(x)−u(x−h)h(1.5)\begin{aligned} u'(x)=&\frac{u(x)-u(x-h)}{h}+\frac{h}{2}u''(x)-\frac{h^2}{6}u'''(x)+...\\ \approx&\frac{u(x)-u(x-h)}{h}\end{aligned}\tag{1.5}

  其误差项为

h2u′′(x)−h26u′′′(x)+...−h2k−2(2k−1)!u(2k−1)(x)+h2k−1(2k)!u(2k)(x)−...(1.6)\frac{h}{2}u''(x)-\frac{h^2}{6}u'''(x)+...-\frac{h^{2k-2}}{(2k-1)!}u^{(2k-1)}(x)+\frac{h^{2k-1}}{(2k)!}u^{(2k)}(x)-...\tag{1.6}

  联立(1.3)(1.3)式与(1.5)(1.5)式，则可以得到一阶微分的中心差分公式

u′(x)=u(x+h)−u(x−h)2h+h2u′′(x)−h26u′′′(x)−...≈u(x+h)−u(x−h)2h(1.7)\begin{aligned} u'(x)=&\frac{u(x+h)-u(x-h)}{2h}+\frac{h}{2}u''(x)-\frac{h^2}{6}u'''(x)-...\\ \approx&\frac{u(x+h)-u(x-h)}{2h}\end{aligned}\tag{1.7}

  其误差项为

−h26u′′′(x)−...−h2k−2(2k−1)!u(2k−1)(x)...(1.8)-\frac{h^2}{6}u'''(x)-...-\frac{h^{2k-2}}{(2k-1)!}u^{(2k-1)}(x)...\tag{1.8}

  在差分公式中，我们关注步长hh对差分公式的影响。一阶微分的向前差分公式和向后差分公式的误差项，都是关于hh的一次式。而一阶微分的中心差分公式的误差项，是关于hh的二次式。故在一阶微分的差分公式中，中心差分公式的误差项次数更高，受步长hh的影响更小，精度更高。故在求一阶微分时，往往使用一阶微分的中心差分公式，以求更高的精度。

1.2.2 二阶微分的差分公式

  我们可以将(1.1)(1.1)式另写作

u(x+h)=u(x)+hu′(x)+h22!u′′(x)+h33!u′′′(x)+h44!u(4)(x)+...(1.9)\begin{aligned} u(x+h)=&u(x)+hu'(x)+\frac{h^2}{2!}u''(x)\\ &+\frac{h^3}{3!}u'''(x)+\frac{h^4}{4!}u^{(4)}(x)+...\end{aligned}\tag{1.9}

  将(1.9)(1.9)式中的hh用2h2h代替，

u(x+2h)=u(x)+2hu′(x)+(2h)22!u′′(x)+(2h)33!u′′′(x)+(2h)44!u(4)(x)+...(1.10)\begin{aligned} u(x+2h)=&u(x)+2hu'(x)+\frac{(2h)^2}{2!}u''(x)\\ &+\frac{(2h)^3}{3!}u'''(x)+\frac{(2h)^4}{4!}u^{(4)}(x)+...\end{aligned}\tag{1.10}

  联立(1.9)(1.9)式与(1.10)(1.10)式，得二阶微分的向前差分公式

u′′(x)=u(x)−2u(x+h)+u(x+2h)h2−(23−2)h3!u′′′(x)−(24−2)h24!u(4)(x)−...≈u(x)−2u(x+h)+u(x+2h)h2(1.11)\begin{aligned} u''(x)=&\frac{u(x)-2u(x+h)+u(x+2h)}{h^2}\\ &-\frac{(2^3-2)h}{3!}u'''(x)-\frac{(2^4-2)h^2}{4!}u^{(4)}(x)-...\\ \approx&\frac{u(x)-2u(x+h)+u(x+2h)}{h^2}\end{aligned}\tag{1.11}

  其误差项为

−(23−2)h3!u′′′(x)−(24−2)h24!u(4)(x)−...(1.12)-\frac{(2^3-2)h}{3!}u'''(x)-\frac{(2^4-2)h^2}{4!}u^{(4)}(x)-...\tag{1.12}

  将(1.11)(1.11)式中的hh用−h-h代替，则可以得到二阶微分的向后差分公式

u′′(x)=u(x−2h)−2u(x−h)+u(x)h2+(23−2)h3!u′′′(x)−(24−2)h24!u(4)(x)+...≈u(x)−2u(x−h)+u(x−2h)h2(1.13)\begin{aligned} u''(x)=&\frac{u(x-2h)-2u(x-h)+u(x)}{h^2}\\ &+\frac{(2^3-2)h}{3!}u'''(x)-\frac{(2^4-2)h^2}{4!}u^{(4)}(x)+...\\ \approx&\frac{u(x)-2u(x-h)+u(x-2h)}{h^2}\end{aligned}\tag{1.13}

  其误差项为

(23−2)h3!u′′′(x)−(24−2)h24!u(4)(x)+...(1.14)\frac{(2^3-2)h}{3!}u'''(x)-\frac{(2^4-2)h^2}{4!}u^{(4)}(x)+...\tag{1.14}

  将(1.9)(1.9)式中的hh用−h-h代替，

u(x−h)=u(x)−hu′(x)+h22!u′′(x)−h33!u′′′(x)+h44!u(4)(x)−...(1.15)\begin{aligned} u(x-h)=&u(x)-hu'(x)+\frac{h^2}{2!}u''(x)\\ &-\frac{h^3}{3!}u'''(x)+\frac{h^4}{4!}u^{(4)}(x)-...\end{aligned}\tag{1.15}

  联立(1.9)(1.9)式与(1.15)(1.15)式，得二阶微分的中心差分公式

u′′(x)=u(x+h)−2u(x)+u(x−h)h2−2h24!u(4)(x)−...≈u(x+h)−2u(x)+u(x−h)h2(1.16)\begin{aligned} u''(x)=&\frac{u(x+h)-2u(x)+u(x-h)}{h^2}-\frac{2h^2}{4!}u^{(4)}(x)-...\\ \approx&\frac{u(x+h)-2u(x)+u(x-h)}{h^2}\end{aligned}\tag{1.16}

  其误差项为

−2h24!u(4)(x)−...(1.17)-\frac{2h^2}{4!}u^{(4)}(x)-...\tag{1.17}

  二阶微分的向前差分公式和向后差分公式的误差项，都是关于hh的一次式。而二阶微分的中心差分公式的误差项，是关于hh的二次式。故在二阶微分的差分公式中，中心差分公式的误差项次数更高，受步长hh的影响更小，精度更高。故在求二阶微分时，往往使用二阶微分的中心差分公式，以求更高的精度。

  但在这里，我们应题目的需要，采用二阶微分的向前差分公式和向后差分公式，并且忽略误差项。

  二阶微分的向前差分公式

u′′(x)=u(x)−2u(x+h)+u(x+2h)h2(1.18)u''(x)=\frac{u(x)-2u(x+h)+u(x+2h)}{h^2}\tag{1.18}

  二阶微分的向后差分公式

u′′(x)=u(x−2h)−2u(x−h)+u(x)h2(1.19)u''(x)=\frac{u(x-2h)-2u(x-h)+u(x)}{h^2}\tag{1.19}

  二阶微分的中心差分公式

u′′(x)=u(x+h)−2u(x)+u(x−h)h2(1.20)u''(x)=\frac{u(x+h)-2u(x)+u(x-h)}{h^2}\tag{1.20}

2 利用中前（后）差分方法求解齐次一维波动方程

2.1 二阶偏微分的差分公式

  由(1.18)(1.18)式易得二阶偏微分的向前差分公式（u(t,x)\pmb{u(t,x)}情况下）：

{∂2u(t,x)∂x2=u(t,x)−2u(t,x+Δx)+u(t,x+2Δx)(Δx)2∂2u(t,x)∂t2=u(t,x)−2u(t+Δt,x)+u(t+2Δt,x)(Δt)2(2.1)\begin{aligned} \begin{cases} \dfrac{\partial^2 u(t,x)}{\partial x^2} = \dfrac{u(t,x) - 2u(t,x+\Delta x) + u(t,x+2\Delta x)}{(\Delta x)^2} \\ \dfrac{\partial^2 u(t,x)}{\partial t^2} = \dfrac{u(t,x) - 2u(t+\Delta t,x) + u(t+2\Delta t,x)}{(\Delta t)^2} \end{cases}\end{aligned}\tag{2.1}

  由(1.19)(1.19)式易得二阶偏微分的向后差分公式（u(t,x)\pmb{u(t,x)}情况下）：

{∂2u(t,x)∂x2=u(t,x−2Δx)−2u(t,x−Δx)+u(t,x)(Δx)2∂2u(t,x)∂t2=u(t−2Δt,x)−2u(t−Δt,x)+u(t,x)(Δt)2(2.2)\begin{aligned} \begin{cases} \dfrac{\partial^2u(t,x)}{\partial x^2}=\dfrac{u(t,x-2\Delta x)-2u(t,x-\Delta x)+u(t,x)}{(\Delta x)^2}\\ \dfrac{\partial^2u(t,x)}{\partial t^2}=\dfrac{u(t-2\Delta t,x)-2u(t-\Delta t,x)+u(t,x)}{(\Delta t)^2} \end{cases}\end{aligned}\tag{2.2}

  由(1.20)(1.20)式易得二阶偏微分的中心差分公式（u(t,x)\pmb{u(t,x)}情况下）：

{∂2u(t,x)∂x2=u(t,x−Δx)−2u(t,x)+u(t,x+Δx)(Δx)2∂2u(t,x)∂t2=u(t−Δt,x)−2u(t,x)+u(t+Δt,x)(Δt)2(2.3)\begin{aligned} \begin{cases} \dfrac{\partial^2u(t,x)}{\partial x^2}=\dfrac{u(t,x-\Delta x)-2u(t,x)+u(t,x+\Delta x)}{(\Delta x)^2}\\ \dfrac{\partial^2u(t,x)}{\partial t^2}=\dfrac{u(t-\Delta t,x)-2u(t,x)+u(t+\Delta t,x)}{(\Delta t)^2} \end{cases}\end{aligned}\tag{2.3}

2.2 齐次一维波动方程介绍

  我们可以先讨论最简单的情况——齐次一维波动方程。作为更复杂的波动方程的参考。

  齐次一维波动方程为：

∂2u(t,x)∂t2=c2⋅∂2u(t,x)∂x2(2.4)\frac{\partial^2u(t,x)}{\partial t^2}=c^2\cdot\frac{\partial^2u(t,x)}{\partial x^2}\tag{2.4}

  在已知t=0\pmb{t=0}时的波形时，我们可以用中后差分方法。

  在已知t=T\pmb{t=T}（T\pmb{T}为总时间）时的波形时，我们可以用中前差分方法。

2.3 齐次一维波动方程的中后差分方法

2.3.1 中后差分方法与差分方程

  中后差分方法是指对空间的二阶导数采用中心差分，对时间的二阶导数采用向后差分。

  对空间的中心差分是指利用上一个空间点x−Δxx-\Delta x，这个空间点xx，下一个空间点x+Δxx+\Delta x，前后兼顾，差分算出导数值。

∂2u(t,x)∂x2=u(t,x−Δx)−2u(t,x)+u(t,x+Δx)(Δx)2(2.5)\frac{\partial^2u(t,x)}{\partial x^2}=\frac{u(t,x-\Delta x)-2u(t,x)+u(t,x+\Delta x)}{(\Delta x)^2}\tag{2.5}

  迭代时，在这个时间点tt，往往只知道上一个空间点x−Δxx-\Delta x，不知道这个空间点xx和下一个空间点x+Δxx+\Delta x。我们可以采取用上个时间点t−Δtt-\Delta t的空间情况来评估这个时间点tt的空间情况。

∂2u(t,x)∂x2≈∂2u(t−Δt,x)∂x2=u(t−Δt,x−Δx)−2u(t−Δt,x)+u(t−Δt,x+Δx)(Δx)2(2.6)\begin{aligned} \frac{\partial^2u(t,x)}{\partial x^2}\approx&\frac{\partial^2u(t-\Delta t,x)}{\partial x^2}\\ =&\frac{u(t-\Delta t,x-\Delta x)-2u(t-\Delta t,x)+u(t-\Delta t,x+\Delta x)}{(\Delta x)^2}\end{aligned}\tag{2.6}

  对时间的向后差分是指利用上上个时间点t−2Δtt-2\Delta t，上个时间点t−Δtt-\Delta t，这个时间点tt，总结过去与现在的情况（因为未来未知），差分算出导数值。

∂2u(t,x)∂t2=u(t−2Δt,x)−2u(t−Δt,x)+u(t,x)(Δt)2(2.7)\frac{\partial^2u(t,x)}{\partial t^2}=\frac{u(t-2\Delta t,x)-2u(t-\Delta t,x)+u(t,x)}{(\Delta t)^2}\tag{2.7}

  将(2.6)(2.6)式和(2.7)(2.7)式带入(2.4)(2.4)式，并对tt和xx离散化，可得差分方程

u(t,x)=c2(Δt)2(Δx)2[u(t−1,x−1)−2u(t−1,x)+u(t−1,x+1)]−u(t−2,x)+2u(t−1,x)(2.8)\begin{aligned} u(t,x)=&c^2\frac{(\Delta t)^2}{(\Delta x)^2}[u(t-1,x-1)-2u(t-1,x)+u(t-1,x+1)]\\ &-u(t-2,x)+2u(t-1,x)\end{aligned}\tag{2.8}

  写成MATLAB代码形式：

1
u(t, x) = (c * dt / dx) ^ 2 * (u(t - 1, x - 1) - 2 * u(t - 1, x) + u(t - 1, x + 1)) - u(t - 2, x) + 2 * u(t - 1, x)

2.3.2 CFL稳定性条件（Courant-Friedrichs-Lewy条件）

  观察(2.8)(2.8)式，取

r=cΔtΔx(2.9)r=c\frac{\Delta t}{\Delta x}\tag{2.9}

  这里的rr即为CFL数（库朗数）。

  CFL稳定性条件是数值分析中用于判断有限差分方法求解偏微分方程时稳定性的重要条件，由三位数学家Richard Courant、Kurt Friedrichs和Hans Lewy于1928年提出。其核心思想是：数值解法的信息传播速度必须不小于原方程的物理信息传播速度，否则计算会因“信息滞后”而发散。主要用于确定时间步长和空间步长之间的关系，以确保数值解的稳定性。

  在一维波动方程中，CFL稳定性条件要求CFL数（库朗数）rr满足：

r=cΔtΔx<1(2.10)r=c\frac{\Delta t}{\Delta x}<1\tag{2.10}

  可得

r2=c2(Δt)2(Δx)2<1(2.11)r^2=c^2\frac{(\Delta t)^2}{(\Delta x)^2}<1\tag{2.11}

  利用(2.11)(2.11)式可以判断、、三者间是否合适。

2.3.3 边界条件

  对于初始条件（已知t=0\pmb{t=0}时的波形），t=Δt\pmb{t=\Delta t}时的波形可以认为与t=0\pmb{t=0}时的波形相同。

u(Δt,x)≈u(0,x)(2.12)u(\Delta t,x)\approx u(0,x)\tag{2.12}

  另外，认为两端固定，长度为LL

u(t,0)=u(t,L)=0(2.13)u(t,0)=u(t,L)=0\tag{2.13}

  >对边界条件利用差分方程，进行若干次迭代差分，即可得到偏微分方程的数值解。具体的MATLAB源代码及其运行结果见下。源代码已上传Github，可以访问链接下载源代码。

2.3.4 MATLAB源代码

  已知t=0\pmb{t=0}时的波形为sin(2πx)\pmb{sin(2\pi x)}。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
clc;
clear; 
close all; 
%% 参数设置
L = 1;
% 空间范围 [0, L]
T = 1;
% 时间范围 [0, T]
c = 1;
% 波速
%% 离散化参数
nx = 100;
% 空间网格数
nt = 200;
% 时间网格数
dx = L / nx;
% 空间步长
dt = T / nt;
% 时间步长
%% CFL稳定性条件检查
CFL = c * dt / dx;
if CFL > 1
    warning('CFL条件不满足，可能导致数值不稳定！');
end
%% 初始化网格
x = linspace(0, L, nx);
t = linspace(0, T, nt);
%% 初始化u(t,x)，同一行表示同一时间，同一列表示同一空间
u = zeros(nt, nx);
%% 边界条件
u(1, :) = sin(2 * pi * x);
u(2, :) = u(1, :);
u(:, 1) = 0;
u(:, end) = 0;
%% 差分方程迭代
for n = 3 : nt
    for i = 2 : nx - 1
        u(n , i)=CFL ^ 2 * (u(n - 1, i - 1) - 2 * u(n - 1, i)...
        + u(n - 1,i + 1)) - u(n - 2, i) + 2 * u(n - 1,i);
    end
end
%% 绘制u(t,x)三维图形
[X, T] = meshgrid(x, t);
figure('Position', [100, 100, 800, 600]);
% 创建一个新的图形窗口，并设置其在屏幕上的位置和大小，四个参数分别为：窗口左下角的 x 坐标，窗口左下角的 y 坐标，窗口宽度，窗口高度
surf(X, T, u, 'EdgeColor', 'none');
% 'EdgeColor', 'none'：设置曲面网格线的颜色为无（即不显示网格线），使图像更平滑
colormap(jet);
% 设置图形的颜色映射方案为jet
colorbar;
% 在图形右侧添加一个颜色条，显示颜色与数值的对应关系
title('一维波动方程 u(x,t) 的数值解');
xlabel('位置 x');
ylabel('时间 t');
zlabel('位移 u(x,t)');
view(30, 30);

2.3.5 MATLAB代码运行结果

2.4 齐次一维波动方程的中前差分方法

2.4.1 中前差分方法与差分方程

  中前差分方法的概念与中后差分方法类似，是指对空间的二阶导数采用中心差分，对时间的二阶导数采用向前差分。

  对空间的中心差分是指利用上一个空间点x−Δxx-\Delta x，这个空间点xx，下一个空间点x+Δxx+\Delta x，前后兼顾，差分算出导数值。

∂2u(t,x)∂x2=u(t,x−Δx)−2u(t,x)+u(t,x+Δx)(Δx)2(2.14)\frac{\partial^2u(t,x)}{\partial x^2}=\frac{u(t,x-\Delta x)-2u(t,x)+u(t,x+\Delta x)}{(\Delta x)^2}\tag{2.14}

  迭代时，在这个时间点，往往只知道上一个空间点x−Δxx-\Delta x，不知道这个空间点xx和下一个空间点x+Δxx+\Delta x。我们可以采取用下个时间点t+Δtt+\Delta t的空间情况来评估这个时间点的空间情况。

∂2u(t,x)∂x2≈∂2u(t+Δt,x)∂x2=u(t+Δt,x−Δx)−2u(t+Δt,x)+u(t+Δt,x+Δx)(Δx)2(2.15)\begin{aligned} \frac{\partial^2u(t,x)}{\partial x^2}\approx&\frac{\partial^2u(t+\Delta t,x)}{\partial x^2}\\ =&\frac{u(t+\Delta t,x-\Delta x)-2u(t+\Delta t,x)+u(t+\Delta t,x+\Delta x)}{(\Delta x)^2}\end{aligned}\tag{2.15}

  对时间的向前差分是指利用下下个时间点t+2Δtt+2\Delta t，下个时间点t+Δtt+\Delta t，这个时间点tt，总结未来与现在的情况（因为过去未知），差分算出导数值。

∂2u(t,x)∂t2=u(t,x)−2u(t+Δt,x)+u(t+2Δt,x)(Δt)2(2.16)\frac{\partial^2u(t,x)}{\partial t^2}=\frac{u(t,x)-2u(t+\Delta t,x)+u(t+2\Delta t,x)}{(\Delta t)^2}\tag{2.16}

  将(2.14)(2.14)式和(2.15)(2.15)式带入(2.4)(2.4)式，带入r=cΔtΔxr=c\frac{\Delta t}{\Delta x}，并对tt和xx离散化，可得差分方程。

u(t,x)=r2[u(t+1,x−1)−2u(t+1,x)+u(t+1,x+1)]+2u(t+1,x)−u(t+2,x)(2.17)\begin{aligned} u(t,x)=&r^2[u(t+1,x-1)-2u(t+1,x)+u(t+1,x+1)]\\ &+2u(t+1,x)-u(t+2,x)\end{aligned}\tag{2.17}

  写成MATLAB代码形式：

1
u(t, x) = (c * dt / dx) ^ 2 * (u(t + 1, x - 1) - 2 * u(t + 1, x) + u(t + 1, x + 1)) + 2 * u(t + 1, x) - u(t + 2, x)

2.4.2 CFL稳定性条件（Courant-Friedrichs-Lewy条件）

  与“2.3.2 CFL稳定性条件（Courant-Friedrichs-Lewy条件）”相同。

r=cΔtΔx<1(2.10)r=c\frac{\Delta t}{\Delta x}<1\tag{2.10}

2.4.3 边界条件

  对于初始条件（已知t=T\pmb{t=T}时的波形），t=T−Δt\pmb{t=T-\Delta t}时的波形可以认为与t=T\pmb{t=T}时的波形相同。

u(T−Δt,x)≈u(T,x)(2.18)u(T-\Delta t,x)\approx u(T,x)\tag{2.18}

  另外，认为两端固定，长度为LL

u(t,0)=u(t,L)=0(2.19)u(t,0)=u(t,L)=0\tag{2.19}

  >对边界条件利用差分方程，进行若干次迭代差分，即可得到偏微分方程的数值解。具体的MATLAB源代码及其运行结果见下。源代码已上传Github，可以访问链接下载源代码。

2.4.4 MATLAB源代码

  已知t=T\pmb{t=T}时的波形为sin(2πx)\pmb{sin(2\pi x)}。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
clc;
clear; 
close all; 
%% 参数设置
L = 1;
% 空间范围 [0, L]
T = 1;
% 时间范围 [0, T]
c = 1;
% 波速
%% 离散化参数
nx = 100;
% 空间网格数
nt = 200;
% 时间网格数
dx = L / nx;
% 空间步长
dt = T / nt;
% 时间步长
%% CFL稳定性条件检查
CFL = c * dt / dx;
if CFL > 1
    warning('CFL条件不满足，可能导致数值不稳定！');
end
%% 初始化网格
x = linspace(0, L, nx);
t = linspace(0, T, nt);
%% 初始化u(t,x)，同一行表示同一时间，同一列表示同一空间
u = zeros(nt, nx);
%% 边界条件
u(end, :) = sin(2 * pi * x);
u(end-1, :) = u(end, :);
u(:, 1) = 0;
u(:, end) = 0;
%% 差分方程迭代
for n = nt - 2 : -1 : 1
    for i = 2 : nx - 1
        u(n, i) = CFL ^ 2 * (u(n + 1, i - 1) - 2 * u(n + 1, i)...
        + u(n + 1, i + 1)) + 2 * u(n + 1, i) - u(n + 2, i);
    end
end
%% 绘制u(t,x)三维图形
[X, T] = meshgrid(x, t);
figure('Position', [100, 100, 800, 600]);
% 创建一个新的图形窗口，并设置其在屏幕上的位置和大小，四个参数分别为：窗口左下角的 x 坐标，窗口左下角的 y 坐标，窗口宽度，窗口高度
surf(X, T, u, 'EdgeColor', 'none');
% 'EdgeColor', 'none'：设置曲面网格线的颜色为无（即不显示网格线），使图像更平滑
colormap(jet);
% 设置图形的颜色映射方案为jet
colorbar;
% 在图形右侧添加一个颜色条，显示颜色与数值的对应关系
title('一维波动方程 u(x,t) 的数值解');
xlabel('位置 x');
ylabel('时间 t');
zlabel('位移 u(x,t)');
view(30, 30);

2.4.5 MATLAB代码运行结果

2.5 中前差分方法与中后差分方法的比较

  比较2.3.4节和2.4.4节的两块代码，不难发现，两者的基本结构是相同的，只是差分方程和边界条件【在已知t=0t=0时的波形时，我们可以用中后差分方法；在已知t=Tt=T（TT为总时间）时的波形时，我们可以用中前差分方法】略有不同。后期我们为了研究问题的简便，只讨论中后差分方法。

3 利用中后差分方法求解非齐次一维波动方程

3.1 非齐次一维波动方程介绍

  在讨论完最简单的情况——齐次一维波动方程之后，我们来讨论非齐次一维波动方程。

  非齐次一维波动方程为：

∂2u(t,x)∂t2=c2⋅∂2u(t,x)∂x2+f(t,x)(3.1)\frac{\partial^2u(t,x)}{\partial t^2}=c^2\cdot\frac{\partial^2u(t,x)}{\partial x^2}+f(t,x)\tag{3.1}

  注意，f(t,x)\pmb{f(t,x)}已知。

  在已知t=0\pmb{t=0}时的波形时，我们可以用中后差分方法。

  在已知t=T\pmb{t=T}（T\pmb{T}为总时间）时的波形时，我们可以用中前差分方法。

  在此，我们只研究第一种情况，原因见2.5节。

3.2 非齐次一维波动方程的中后差分方法

3.2.1 中后差分方法与差分方程

  这里的中后差分方法与2.3.1节概念相同，可得

{∂2u(t,x)∂x2=u(t−Δt,x−Δx)−2u(t−Δt,x)+u(t−Δt,x+Δx)(Δx)2∂2u(t,x)∂t2=u(t−2Δt,x)−2u(t−Δt,x)+u(t,x)(Δt)2(3.2)\begin{aligned} \begin{cases} \dfrac{\partial^2u(t,x)}{\partial x^2}=\dfrac{u(t-\Delta t,x-\Delta x)-2u(t-\Delta t,x)+u(t-\Delta t,x+\Delta x)}{(\Delta x)^2}\\ \dfrac{\partial^2u(t,x)}{\partial t^2}=\dfrac{u(t-2\Delta t,x)-2u(t-\Delta t,x)+u(t,x)}{(\Delta t)^2} \end{cases}\end{aligned}\tag{3.2}

  将(3.2)(3.2)式带入(3.1)(3.1)式，带入r=cΔtΔxr=c\frac{\Delta t}{\Delta x}，并对tt和xx离散化，可得差分方程

u(t,x)=r2[u(t−1,x−1)−2u(t−1,x)+u(t−1,x+1)]−u(t−2,x)+2u(t−1,x)+f(t,x)(3.3)\begin{aligned} u(t,x)=&r^2[u(t-1,x-1)-2u(t-1,x)+u(t-1,x+1)]\\ &-u(t-2,x)+2u(t-1,x)+f(t,x)\end{aligned}\tag{3.3}

  写成MATLAB代码形式：

1
u(t, x) = (c * dt / dx) ^ 2 * (u(t - 1, x - 1) - 2 * u(t - 1, x) + u(t - 1, x + 1)) - u(t - 2, x) + 2 * u(t - 1, x) + f(t, x)

3.2.2 CFL稳定性条件（Courant-Friedrichs-Lewy条件）

  与“2.3.2 CFL稳定性条件（Courant-Friedrichs-Lewy条件）”相同。

r=cΔtΔx<1(2.10)r=c\frac{\Delta t}{\Delta x}<1\tag{2.10}

3.2.3 边界条件

  与2.3.3节相同。

  对于初始条件（已知t=0\pmb{t=0}时的波形），t=Δt\pmb{t=\Delta t}时的波形可以认为与t=0\pmb{t=0}时的波形相同。

u(Δt,x)≈u(0,x)(3.4)u(\Delta t,x)\approx u(0,x)\tag{3.4}

  另外，认为两端固定，长度为LL

u(t,0)=u(t,L)=0(3.5)u(t,0)=u(t,L)=0\tag{3.5}

  对边界条件利用差分方程，进行若干次迭代差分，即可得到偏微分方程的数值解。具体的MATLAB源代码及其运行结果见下。源代码已上传Github，可以访问链接下载源代码。

3.2.4 MATLAB源代码

  已知t=0\pmb{t=0}时的波形为sin(2πx)\pmb{sin(2\pi x)}，f(t,x)=x\pmb{f(t,x)=x}。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
clc;
clear; 
close all; 
%% 参数设置
L = 3;
% 空间范围 [0, L]
T = 6;
% 时间范围 [0, T]
c = 1;
% 波速
%% 离散化参数
nx = 100;
% 空间网格数
nt = 200;
% 时间网格数
dx = L / nx;
% 空间步长
dt = T / nt;
% 时间步长
%% CFL稳定性条件检查
CFL = c * dt / dx;
if CFL > 1
    warning('CFL条件不满足，可能导致数值不稳定！');
end
%% 初始化网格
x = linspace(0, L, nx);
t = linspace(0, T, nt);
%% 初始化u(t,x)，同一行表示同一时间，同一列表示同一空间
u = zeros(nt, nx);
%% 边界条件
u(1, :) = sin(2 * pi * x);
u(2, :) = u(1, :);
u(:, 1) = 0;
u(:, end) = 0;
%% 差分方程迭代
for n = 3 : nt
    for i = 2 : nx - 1
        u(n, i) = CFL ^ 2 * (u(n - 1, i - 1) - 2 * u(n - 1, i)...
        + u(n - 1,i + 1)) - u(n - 2, i) + 2 * u(n - 1, i)...
        + f(n, i);
    end
end
%% 绘制u(t,x)三维图形
[X, T] = meshgrid(x, t);
figure('Position', [100, 100, 800, 600]);
% 创建一个新的图形窗口，并设置其在屏幕上的位置和大小，四个参数分别为：窗口左下角的 x 坐标，窗口左下角的 y 坐标，窗口宽度，窗口高度
surf(X, T, u, 'EdgeColor', 'none');
% 'EdgeColor', 'none'：设置曲面网格线的颜色为无（即不显示网格线），使图像更平滑
colormap(jet);
% 设置图形的颜色映射方案为jet
colorbar;
% 在图形右侧添加一个颜色条，显示颜色与数值的对应关系
title('一维波动方程 u(x,t) 的数值解');
xlabel('位置 x');
ylabel('时间 t');
zlabel('位移 u(x,t)');
view(30, 30); 
%% 定义f(t, x)
function f=f(t, x)
    f = x;
end

3.2.5 MATLAB代码运行结果

3.3 解齐次方程与解非齐次方程的比较

  比较2.3.4节和3.2.4节的两块代码，不难发现，两者的基本结构是相同的，只是在3.2.4节的差分方程最后面多了f(t,x)\pmb{f(t,x)}项，在全部代码最后多了一个定义函数f(t,x)\pmb{f(t,x)}的代码块。后期我们为了研究问题的简便，只讨论解齐次方程。

4 利用中后差分方法求解齐次二维波动方程

4.1 齐次二维波动方程介绍

  我们接下来讨论齐次二维波动方程。

  齐次二维波动方程为：

∂2u(t,x,y)∂t2=c2⋅[∂2u(t,x,y)∂x2+∂2u(t,x,y)∂y2](4.1)\frac{\partial^2u(t,x,y)}{\partial t^2}=c^2\cdot\left[\frac{\partial^2u(t,x,y)}{\partial x^2}+\frac{\partial^2u(t,x,y)}{\partial y^2}\right]\tag{4.1}

  在已知t=0\pmb{t=0}时的波形时，我们可以用中后差分方法。

  在已知t=T\pmb{t=T}（T为总时间）时的波形时，我们可以用中前差分方法。

4.2 齐次二维波动方程的中后差分方法

4.2.1 中后差分方法与差分方程

  这里的中后差分方法与2.3.1节概念相同，可类比得

{∂2u(t,x,y)∂x2=u(t−Δt,x−Δx,y)−2u(t−Δt,x,y)+u(t−Δt,x+Δx,y)(Δx)2∂2u(t,x,y)∂y2=u(t−Δt,x,y−Δy)−2u(t−Δt,x,y)+u(t−Δt,x,y+Δy)(Δy)2∂2u(t,x,y)∂t2=u(t−2Δt,x,y)−2u(t−Δt,x,y)+u(t,x,y)(Δt)2(4.2)\begin{aligned} \begin{cases} \dfrac{\partial^2u(t,x,y)}{\partial x^2}=\\ \dfrac{u(t-\Delta t,x-\Delta x,y)-2u(t-\Delta t,x,y)+u(t-\Delta t,x+\Delta x,y)}{(\Delta x)^2}\\ \dfrac{\partial^2u(t,x,y)}{\partial y^2}=\\ \dfrac{u(t-\Delta t,x,y-\Delta y)-2u(t-\Delta t,x,y)+u(t-\Delta t,x,y+\Delta y)}{(\Delta y)^2}\\ \dfrac{\partial^2u(t,x,y)}{\partial t^2}=\\ \dfrac{u(t-2\Delta t,x,y)-2u(t-\Delta t,x,y)+u(t,x,y)}{(\Delta t)^2} \end{cases}\end{aligned}\tag{4.2}

  将(4.2)(4.2)式带入(4.1)(4.1)式，并对tt、xx和yy离散化，可得差分方程

u(t,x,y)=c2(Δt)2(Δx)2[u(t−1,x−1,y)−2u(t−1,x,y)+u(t−1,x+1,y)]+c2(Δt)2(Δy)2[u(t−1,x,y−1)−2u(t−1,x,y)+u(t−1,x,y+1)]−u(t−2,x,y)+2u(t−1,x,y)(4.3)\begin{aligned} u&(t,x,y)=\\ &c^2\frac{(\Delta t)^2}{(\Delta x)^2}[u(t-1,x-1,y)-2u(t-1,x,y)+u(t-1,x+1,y)]\\ +&c^2\frac{(\Delta t)^2}{(\Delta y)^2}[u(t-1,x,y-1)-2u(t-1,x,y)+u(t-1,x,y+1)]\\ -&u(t-2,x,y)+2u(t-1,x,y)\end{aligned}\tag{4.3}

  写成MATLAB代码形式：

1
u(t, x, y) = (c * dt / dx) ^ 2 * (u(t - 1, x - 1, y) - 2 * u(t - 1, x, y) + u(t - 1, x + 1, y)) + (c * dt / dy) ^ 2 * (u(t - 1, x, y - 1) - 2 * u(t - 1, x, y) + u(t - 1, x, y + 1)) - u(t - 2, x, y) + 2 * u(t - 1, x, y)

4.2.2 CFL稳定性条件（Courant-Friedrichs-Lewy条件）

  在二维波动方程中，CFL稳定性条件要求CFL数rr（库朗数）满足：

r=cΔt1(Δx)2+1(Δy)2<1(4.4)r=c\Delta t\sqrt{\frac{1}{(\Delta x)^2}+\frac{1}{(\Delta y)^2}}<1\tag{4.4}

4.2.3 边界条件

  对于初始条件（已知t=0\pmb{t=0}时的波形），t=Δt\pmb{t=\Delta t}时的波形可以认为与t=0\pmb{t=0}时的波形相同。

u(Δt,x,y)≈u(0,x,y)(4.5)u(\Delta t,x,y)\approx u(0,x,y)\tag{4.5}

  另外，认为两端固定，xx方向长度为LxL_x，方向长度为LyL_y

u(t,0,y)=u(t,Lx,y)=u(t,x,0)=u(t,x,Ly)=0(4.6)u(t,0,y)=u(t,L_x,y)=u(t,x,0)=u(t,x,L_y)=0\tag{4.6}

  对边界条件利用差分方程，进行若干次迭代差分，即可得到偏微分方程的数值解。具体的MATLAB源代码及其运行结果见下。源代码已上传Github，可以访问链接下载源代码。

4.2.4 MATLAB源代码

  已知t=0\pmb{t=0}时的波形为e−(x−0.5Lx)2+(y−0.5Ly)20.02\pmb{e^{-\frac{(x-0.5L_x)^2+(y-0.5L_y)^2}{0.02}}}。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
clc;
clear;
close all;
%% 参数设置
Lx = 1;
% x方向长度
Ly = 1;
% y方向长度
T = 5;
% 总时间
c = 1;
% 波速
%% 离散化参数
nx = 100;
% x方向网格数
ny = 100;
% y方向网格数
nt = 2000;
% 时间步数
dx = Lx/nx;
% x方向步长
dy = Ly/ny;
% y方向步长
dt = T/nt;
% 时间步长
%% 稳定性条件检查
CFL = c*dt*sqrt(1/dx^2 + 1/dy^2);
if CFL >= 1
    warning('CFL条件不满足，可能导致数值不稳定！');
end
%% 初始化网格
x = linspace(0, Lx, nx);
y = linspace(0, Ly, ny);
t = linspace(0, T, nt);
%% 初始化u(t,y,x)
u = zeros(nt, nx, ny);
%% 边界条件
for i = 1 : nx
    for j = 1 : ny
        x0 = x(i);
        y0 = y(j);
        u(1, i, j) = exp(- ((x0 - 0.5 * Lx) .^ 2...
        + (y0 - 0.5 * Ly) .^ 2) / 0.02);
    end
end
u(2, :, :) = u(1, :, :);
u(:, 1, :) = 0;
u(:, end, :) = 0;
u(:, :, 1) = 0;
u(:, :, end) = 0;
%% 差分方程迭代
for n = 3 : nt
    for i = 2 : nx - 1
        for j = 2 : ny - 1
            u(n, i, j) = (c * dt / dx) ^ 2...
            * (u(n - 1, i - 1, j) - 2 * u(n - 1, i, j)...
            + u(n - 1, i + 1, j))+ (c * dt / dy) ^ 2...
            * (u(n - 1, i, j - 1) - 2 * u(n - 1, i, j)...
            + u(n - 1, i, j + 1)) - u(n - 2, i, j)...
            + 2 * u(n - 1, i, j);
        end
    end
end
%% 画图
figure('Position', [100, 100, 800, 600]);
% 创建一个新的图形窗口，并设置其在屏幕上的位置和大小，四个参数分别为：窗口左下角的 x 坐标，窗口左下角的 y 坐标，窗口宽度，窗口高度
for n = 1 : nt
    [X, Y] = meshgrid(x, y);
    u0 = [];
    for y0 = 1 : ny
        u0 = [u0; u(n, :, y0)];
    end
    %u0是将1*nx*ny的三维数组二维化的nx*ny数组
    surf(X, Y, u0, 'EdgeColor', 'none');
    % 'EdgeColor', 'none'：设置曲面网格线的颜色为无（即不显示网格线），使图像更平滑
    colormap(jet);
    % 设置图形的颜色映射方案为jet
    colorbar;
    % 在图形右侧添加一个颜色条，显示颜色与数值的对应关系
    zlim([-2 2])
    title(sprintf('二维波动方程 u(x,y,t) 的数值解 t = %.3f', n*dt))
    xlabel('位置 x');
    ylabel('位置 y');
    zlabel('位移 u(x,y,t)');
    view(30, 30);
    pause(0.001);
    drawnow limitrate;
    % 强制MATLAB立即更新图形
end

4.2.5 MATLAB代码运行结果（精简后）

5 总结

  本文用中后差分与中前差分两种格式，依次求解了齐次一维、非齐次一维与齐次二维波动方程。把四个算例放在一起看，可以得到一条统一的方法——无论方程是几维、是否非齐次，求解程序都是同一个骨架，只是替换其中的差分方程与边界条件：

  第一步，把方程离散化。 用二阶中心差分近似时间与空间二阶导数，得到显式递推式，由前两个时间层直接算出下一层，无需解方程组。第二步，处理边界与初始条件。 一维问题的两点边界、二维问题的四条边界都要在每个时间步单独赋值。第三步，检查 CFL 条件。 显式格式并非无条件稳定，时间步必须满足 r=cΔt/Δx<1r=c\Delta t/\Delta x<1（二维为 r=cΔt1/Δx2+1/Δy2<1r=c\Delta t\sqrt{1/\Delta x^2+1/\Delta y^2}<1），否则数值解会振荡发散。第四步，迭代推进。

  对比两种格式的选择依据很清楚：

中后差分中前差分
适用条件已知 t=0t=0 时刻的波形已知 t=Tt=T（终了时刻）的波形
推进方向由初始层向前推进由终了层向后推进
程序结构完全相同，仅差分方程与边界条件略有不同同左

  两者代码骨架一致，差别仅在于差分方程中时间项的符号与边界条件的赋值方式。因此本题的核心结论不是某个具体方程怎么解，而是：掌握了这套骨架后，把差分方程换成非齐次的（多一项 f(t,x)f(t,x)）、把空间维数提到三维，程序只需小幅改动即可复用。CFL 条件也同样可以推广——三维时要求

r=cΔt1(Δx)2+1(Δy)2+1(Δz)2<1(5.1)r=c\Delta t\sqrt{\frac{1}{(\Delta x)^2}+\frac{1}{(\Delta y)^2}+\frac{1}{(\Delta z)^2}}<1\tag{5.1}

  需要指出本文的局限：所有算例都验证了格式的可用性与稳定性，但没有做精度阶的定量对比（即把数值解与解析解逐点作差、拟合误差随步长的下降速率），也没有讨论隐式格式（如 Crank–Nicolson）在放宽 CFL 限制上的价值。这些是有待补充的部分。

致谢

  感谢MATLAB老师这一个学期的耐心教导！

  感谢父母与朋友在生活中无微不至的照顾！

  在我这么多朋友中，我尤其感谢远在河北某本科上学的异父异母的亲兄弟——Hana，感谢他在编程方面对我的帮助。感谢他凌晨一点半还热心地教我怎样在Github上上传文件，我的博客网站得以建成，他功不可没。

]]> https://primerusse.top/2025/06/27/202506270100/ 2025-06-26T17:00:00.000Z 前向、后向、中心差分求解波动方程。 MATLAB 差分法求解波动方程：三种差分格式的精度对比 2025-06-26T17:00:00.000Z Primerusse 1 为什么用元胞自动机做交通流

  交通拥堵有个反直觉的地方：它并不是由某个“堵点”造成的，而是大量车辆按各自简单规则行驶时，自发涌现出来的集体现象。前车减速、后车跟着减速、减速逐级放大——这种“走走停停”的波（stop-and-go wave）在没有路口、没有事故的笔直路段上也会出现。

  要研究这种涌现，宏观连续模型（把车流当作可压缩流体）就不太够用了：它擅长描述整体的流量—密度—速度关系，却难以刻画单个驾驶员的行为如何逐级放大成拥堵。元胞自动机（Cellular Automaton）恰好补上这一环——道路被离散成一维元胞格，每格有车或没车，每辆车按固定规则更新位置与速度，规则简单到可以逐条写清楚，但迭代足够多步之后，拥堵会自己长出来。

  本文实现的是这一思路最经典的模型：NaSch 模型（Nagel 与 Schreckenberg，1992）。它的四条更新规则只有加速、减速、随机减速、前进——随机减速那一项是关键，正是它让车流从自由流相变为拥堵流。

  本文用 MATLAB 完整实现该模型，给出源代码与三组不同参数下的运行结果，用于对比不同参数对拥堵形成的影响。

2 交通流理论基础

  描述一段路上的车流，最常用的三个量是：流量 QQ（单位时间通过断面的车辆数）、速度 VV、密度 KK（单位长度上的车辆数）。三者满足一个简单关系：

Q=K×VQ=K\times V

  这个式子看着平常，但它约束了车流的基本行为：密度很小时车可以跑得快、流量随密度上升；密度增大到一定程度后车速被迫下降，流量反而减少——最终在堵死时速度与流量都归零。把 QQ 对 KK 作图得到的曲线即基本图，是判别交通运行状态的基本工具。

  围绕 QQ–KK–VV 的关系，交通流模型分两大类。宏观连续模型把车流当作可压缩流体，用密度、速度的连续方程描述整体演化，擅长给出 QQ–KK 关系的解析形式（如格林希尔茨线性模型、格林伯格对数模型），但无法刻画单个驾驶员的行为。微观模型（跟驰模型、元胞自动机）则逐个描述车辆，规则简单但能自然产生集体现象——拥堵的形成与消散正是这类模型最擅长解释的问题。

  本文采用的是元胞自动机一类中最经典的 NaSch 模型。

3 元胞自动机模型（NaSch模型）构建与优化

3.1 元胞自动机模型（NaSch模型）原理[4]

  NaSch 模型由 Nagel 与 Schreckenberg 于 1992 年提出。道路被离散成一条一维元胞链，每个元胞只有“有车”和“空”两种状态，一个元胞至多容纳一辆车；每辆车带有 0 到 vmaxv_{max} 之间的整数速度。模型每次迭代按顺序执行以下四个操作（四个步骤对全体车辆同时进行）：

  1.广泛性加速

  对于所有未达到最大速度vmaxv_{max}（道路的速度限制）的车辆，加速一个单位，即vn→min{vn+1,vmax}v_n\rightarrow min\left\{v_n+1,v_{max}\right\}。

  2.安全性减速

  在进行第a步之后，如果它的速度大于与前车间距的空元胞dnd_n，则它将速度降低到vnv_n，vn→min{dn,vn}v_n\rightarrow min\left\{d_n,v_n\right\}。其中dn=xn+1−xn−lnd_n=x_{n+1}-x_n-l_n，xnx_n代表车辆的位置，lnl_n代表车辆的长度。这里为了简化模型，假设ln=1\pmb{l_n=1}，假设各车最大减速加速度为正无穷大，即可以不耗时地减速至任意速度，避免模型中出现撞车的情形。

  3.随机减速

  对于速度大于00的汽车，速度以概率pp减少一个单位，即vn→发生的概率为pmax{vn−1,0}v_n\xrightarrow{发生的概率为p}max\left\{v_n-1,0\right\}。

  4.车辆更新

  在步骤1-3之后，基于其当前速度vnv_n，为每辆汽车分配新的位置xn→xn+vnx_n\rightarrow x_n+v_n。对于该模型在时刻t→t+1t\rightarrow t+1的演化过程如下图1所示。经过一次1-4步骤称为一次迭代。

图1 四个基本操作控制示例图

图1 四个基本操作控制示例图

3.2 参数定义

  模型共 5 个输入参数：

参数含义作用
NN车辆数与道路长度共同决定初始密度 KK
RR初始状态最右端车辆位置即道路长度（元胞总数）
vmaxv_{max}最大速度道路限速；决定自由流速度
pp随机减速概率模型的关键参数，刻画驾驶行为的随机性
TT模拟迭代次数演化总步数

  其中 pp 是 NaSch 模型的精髓所在。若取 p=0p=0（完全确定性），车流最终会演化成一个稳定的周期状态，永远不会自发形成拥堵；只有当 p>0p>0 时，随机减速造成的微小扰动才会逐级放大，最终触发自由流到拥堵流的相变。

3.3 建模思路

3.3.1 整体思路

  建立一个长度NN为的行向量xltxlt

xlt=[x1,x2,...,xN]xlt=[x_1,x_2,...,x_N]

来表示这辆车的位置。其中，的元素在满足

1≤xi≤R,xi∈N∗1\le x_i\le R,x_i\in N^*

的条件下，初始随机化。

  再建立一个长度为NN的行向量vltvlt

vlt=[v1,v2,...,vN]vlt=[v_1,v_2,...,v_N]

来表示这辆车的速度。其中，vltvlt的元素viv_i在满足

1≤vi≤vmax,vi∈N∗1\le v_i\le v_{max},v_i\in N^*

  在xltxlt和vltvlt的基础上进行一次迭代，更新xltxlt和vltvlt内各元素的值。

  重复迭代TT次，输出最终的xltxlt和vltvlt。

3.3.2 对于一次迭代

  对于一次迭代，可视为一个函数。其输入值是迭代前的（初始的或上一次迭代后的）和，其输出值是迭代后的xltxlt和vltvlt。

  对于一次迭代，有四次操作。每次操作，遍历nn从11到NN：

vn→min{vn+1,vmax}v_n\rightarrow min\left\{v_n+1,v_{max}\right\}

vn→min{xn+1−xn−ln,vn}v_n\rightarrow min\left\{x_{n+1}-x_n-l_n,v_n\right\}

vn→发生的概率为pmax{vn−1,0}v_n\xrightarrow{发生的概率为p}max\left\{v_n-1,0\right\}

xn→xn+vnx_n\rightarrow x_n+v_n

  注意到，前三次操作，都只牵扯到vltvlt的修改与更新，并没有修改xltxlt。并且vnv_n的值与vn+1v_{n+1}无关。故可将前三次操作分别进行三次遍历简化为一次遍历下的三次操作。即简化为：

  遍历nn从11到NN：

vn→min{vn+1,vmax}v_n\rightarrow min\left\{v_n+1,v_{max}\right\}

vn→min{xn+1−xn−ln,vn}v_n\rightarrow min\left\{x_{n+1}-x_n-l_n,v_n\right\}

vn→发生的概率为pmax{vn−1,0}v_n\xrightarrow{发生的概率为p}max\left\{v_n-1,0\right\}

  遍历nn从11到NN：

xn→xn+vnx_n\rightarrow x_n+v_n

  此次迭代结束，输出迭代后的xltxlt和vltvlt。

3.3.3 MATLAB源代码

  本文中使用的MATLAB版本是R2024b。

  根据3.3 建模思路，可以写出以下的MATLAB源代码。源代码已上传Github，可以点击链接，下载源代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
clc;
clear;
%输入参数
N = input('车辆数N:');
R = input('初始状态最右端车辆位置R：');
vmax = input('最大速度vmax:');
p = input('随机减速概率p:');
T = input('模拟迭代次数T:');

disp('初始状态：')
%随机生成1xN大小的递增的行向量xlt,要求所有元素大于等于1，小于等于R
xlt = sort(randperm(R, N))
%随机生成1xN大小的行向量vlt
vlt = randi([0, vmax], 1, N)

%进行T次迭代
for i = 1:T
    [xlt, vlt] = lteration(xlt, vlt, N, vmax, p);
end

%输出结果
disp('最终状态：')
xlt
vlt

%一次迭代函数定义
function [x, v] = lteration(xlt0, vlt0, n, vmax, p)
    x = xlt0;
    v = vlt0;
    x(n + 1) = inf;
    for i = 1:n
        v(i) = min(v(i) + 1, vmax);
        v(i) = min(x(i + 1) - x(i) - 1, v(i));
        % 以概率p执行
        if rand < p
            v(i) = max(v(i) - 1, 0);
        end
    end
    for i = 1:n
        x(i) = x(i) + v(i);
    end
    x(n + 1) = [];
end

3.3.4 样例输出

3.3.4.1 样例1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
车辆数N:4
初始状态最右端车辆位置R：7
最大速度vmax:2
随机减速概率p:0.3
模拟迭代次数T:50
初始状态：
xlt =
3 5 6 7
vlt =
1 2 2 0
最终状态：
xlt =
68 71 75 82
vlt =
2 1 2 2
3.3.4.2 样例2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
车辆数N:4
初始状态最右端车辆位置R：7
最大速度vmax:2
随机减速概率p:0.3
模拟迭代次数T:50
初始状态：
xlt =
2 3 4 6
vlt =
1 1 0 0
最终状态：
xlt =
73 79 83 89
vlt =
2 2 2 1
3.3.4.3 样例3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
车辆数N:100
初始状态最右端车辆位置R：1000
最大速度vmax:5
随机减速概率p:0.1
模拟迭代次数T:30
初始状态：
xlt =
列 1 至 10
1 9 18 24 47 95 108 125 127 160
列 11 至 20
166 175 176 179 181 208 220 221 223 228
列 21 至 30
239 247 261 264 265 270 284 301 313 323
列 31 至 40
346 356 388 389 391 411 454 461 467 495
列 41 至 50
503 504 508 524 532 538 547 552 556 582
列 51 至 60
583 622 645 646 654 657 679 717 720 732
列 61 至 70
737 743 759 760 761 762 777 789 790 797
列 71 至 80
801 802 809 815 819 832 833 843 853 856
列 81 至 90
858 859 881 890 916 917 918 921 943 948
列 91 至 100
955 956 959 964 967 968 982 989 995 998
vlt =
列 1 至 10
0 2 1 1 4 1 1 0 1 4
列 11 至 20
2 3 5 2 3 5 2 3 1 5
列 21 至 30
1 1 5 2 1 0 1 1 5 4
列 31 至 40
4 5 2 4 2 4 2 5 0 5
列 41 至 50
1 0 0 2 5 1 4 1 4 1
列 51 至 60
0 5 4 5 5 3 5 2 5 0
列 61 至 70
0 4 2 2 3 0 2 0 4 3
列 71 至 80
0 2 2 3 1 0 2 4 3 5
列 81 至 90
1 1 1 4 4 5 4 3 2 3
列 91 至 100
5 5 2 0 2 3 0 5 5 2
最终状态：
xlt =
列 1 至 5
140 149 157 163 192
列 6 至 10
237 250 261 267 282
列 11 至 15
297 303 311 317 325
列 16 至 20
333 341 350 358 368
列 21 至 25
374 380 389 396 402
列 26 至 30
408 426 440 461 471
列 31 至 35
494 500 517 523 529
列 36 至 40
556 582 592 599 617
列 41 至 45
626 634 641 658 665
列 46 至 50
675 682 691 704 712
列 51 至 55
721 770 778 784 792
列 56 至 60
799 819 827 833 841
列 61 至 65
847 856 866 872 882
列 66 至 70
889 896 905 912 917
列 71 至 75
923 928 934 940 945
列 76 至 80
951 959 965 973 981
列 81 至 85
991 997 1011 1017 1024
列 86 至 90
1037 1043 1048 1057 1063
列 91 至 95
1070 1077 1085 1092 1097
列 96 至 100
1111 1117 1127 1133 1141
vlt =
列 1 至 10
5 4 5 5 5 5 5 5 5 5
列 11 至 20
5 5 5 4 5 5 5 5 5 5
列 21 至 30
5 4 5 5 5 5 5 5 5 5
列 31 至 40
5 5 5 5 5 5 5 5 5 5
列 41 至 50
5 4 5 5 5 5 5 5 5 5
列 51 至 60
5 5 5 5 5 5 5 5 5 5
列 61 至 70
5 5 5 5 5 5 5 4 5 4
列 71 至 80
5 4 5 5 4 5 5 5 5 5
列 81 至 90
5 5 5 5 5 5 5 4 5 5
列 91 至 100
5 5 5 5 4 5 5 5 5 5

致谢

  感谢Matlab老师这一个学期的耐心教导！

  感谢父母与朋友在生活中无微不至的照顾！

  在我这么多朋友中，我尤其感谢远在河北某本科上学的异父异母的亲兄弟——Hana，感谢他在编程方面对我的帮助。感谢他凌晨一点半还热心地教我怎样在Github上上传文件，我的博客网站得以建成，他功不可没。

]]> https://primerusse.top/2025/06/27/202506270000/ 2025-06-26T16:00:00.000Z 用元胞自动机复现拥堵的形成与消散。 MATLAB 实现交通流元胞自动机模型（NaSch 模型） 2025-06-26T16:00:00.000Z