# Python低溫半导体电子束量子波算法计算

{% hint style="success" %}
Python | 物理 | 数学 | 泊松方程 | 求解器 | 三维投影 | 二维 | 静电场 | 静磁场 | 矩阵算子 | 低温 | 半导体 | 条件 | 量子 | 电子束 | 曲面 | 达西流 | 原子模拟
{% endhint %}

{% embed url="https://viadean.notion.site/Python-a9f4d4e390d142c6ab79a6395999154d" %}

{% content-ref url="../zhi-dian-mi-jin-brief" %}
[zhi-dian-mi-jin-brief](../zhi-dian-mi-jin-brief)
{% endcontent-ref %}

### 🎯要点

🎯任意维度求解器，绘制三维投影结果 | 🎯解二维静电场、静磁场 | 🎯狄利克雷、诺依曼条件几何矩阵算子 | 🎯算法模拟低溫半导体材料 | 🎯计算曲面达西流 | 🎯电子结构计算和原子模拟 | 🎯算法模拟量子波函数和电子束

#### 📜泊松方程 | 本文 - 用例

📜[Python火焰锋动力学和浅水表面波浪偏微分方程](python-huo-yan-feng-dong-li-xue-he-qian-shui-biao-mian-bo-lang-pian-wei-fen-fang-cheng)

📜[Python数值和符号算法计算及3D视图物理数学波形方程](../wu-li-xue-physics/python-shu-zhi-he-fu-hao-suan-fa-ji-suan-ji-3d-shi-tu-wu-li-shu-xue-bo-xing-fang-cheng)

📜[Python射频电磁肿瘤热疗数学模型和电磁爆炸性变化统计推理模型](../suan-fa-mo-xing-algorithm/python-she-pin-dian-ci-zhong-liu-re-liao-shu-xue-mo-xing-he-dian-ci-bao-zha-xing-bian-hua-tong-ji-tu)

📜[达西流用例：​Python和R水力电导率和达西流神经算子](../wu-li-xue-physics/python-hershui-li-dian-daolhe-da-xi-liu-shen-jing-suan-zi)

### 🍇Python最低阶有限差分泊松方程

我们想要解泊松方程：

$$
\frac{\partial^2 u}{\partial x^2}+\frac{\partial^2 u}{\partial y^2}=0
$$

在 $$[0,1] \times[0,1]$$ 方域中，具有边界条件

$$
u(x, 0)=x, \quad u(x, 1)=x-1, \quad u(0, y)=-y, \quad u(1, y)=1-y .
$$

我们将使用最低阶有限差分表示：

$$
\begin{gathered} \frac{\partial^2 u}{\partial x^2}\left(x_i, y_j\right) \simeq \frac{1}{\Delta x}\left(\frac{\partial u}{\partial x}\left(x_{i+1}, y_j\right)-\frac{\partial u}{\partial x}\left(x_{i-1}, y_j\right)\right) \\ \simeq \frac{1}{\Delta x}\left(\frac{1}{\Delta x}\left(u\left(x_{i+1}, y_j\right)-u\left(x_i, y_j\right)\right)-\frac{1}{\Delta x}\left(u\left(x_i, y_j\right)-u\left(x_{i-1}, y_j\right)\right)\right) \end{gathered}
$$

#### 📜[有限差分用例：Python微磁学磁倾斜和西塔规则算法](../suan-fa-mo-xing-algorithm/python-wei-ci-xue-ci-qing-xie-he-xi-ta-gui-ze-suan-fa)

最终简化为，

$$
\frac{\partial^2 u}{\partial x^2}+\frac{\partial^2 u}{\partial y^2} \simeq\left(\frac{1}{\Delta^2}\left(u_{i+1, j}+u_{i-1, j}+u_{i, j+1}+u_{i, j-1}-4 u_{i, j}\right)\right)
$$

最直接的方法是直接求解线性系统：

```python
 import numpy as np
 import matplotlib as ml
 import matplotlib.pyplot as pp
```

```python
 def boundary(grid):
     x = np.linspace(0,1,len(grid))
     
     grid[0,:]  = np.interp(x,[0,1],[0,1])
     grid[:,-1] = np.interp(x,[0,1],[1,0])
     grid[-1,:] = np.interp(x,[0,1],[-1,0])
     grid[:,0]  = np.interp(x,[0,1],[0,-1])
```

```python
 def poisson_direct(gridsize,set_boundary):
     A = np.zeros(shape=(gridsize,gridsize,gridsize,gridsize),dtype='d')
     b = np.zeros(shape=(gridsize,gridsize),dtype='d')
     
     dx = 1.0 / (gridsize - 1)
     
     
     for i in range(1,gridsize-1):
         for j in range(1,gridsize-1):
             A[i,j,i-1,j] = A[i,j,i+1,j] = A[i,j,i,j-1] = A[i,j,i,j+1] = 1/dx**2
             A[i,j,i,j] = -4/dx**2
     
     
     for i in range(0,gridsize):
         A[0,i,0,i] = A[-1,i,-1,i] = A[i,0,i,0] = A[i,-1,i,-1] = 1
     
     
     set_boundary(b)
     
     return np.linalg.tensorsolve(A,b)
```

```python
 sol = poisson_direct(25,boundary)
```

为了展示解，我们需要将矩阵的通常解释（行、列、从上到左）与在笛卡尔平面上绘图的想法联系起来。

```python
 pp.imshow(sol.T,cmap=ml.cm.Blues,interpolation='none',origin='lower')
```

将其变成我们将再次使用的函数。

```python
 def showsol(sol):
     pp.imshow(sol.T,cmap=ml.cm.Blues,interpolation='none',origin='lower')
```

```
 showsol(poisson_direct(51,boundary))
```

让我们尝试一种迭代方法：我们将泊松方程转化为扩散方程来求解

$$
\frac{\partial u}{\partial t}=\frac{\partial^2 u}{\partial x^2}+\frac{\partial^2 u}{\partial y^2}
$$

并通过正向时间中心空间差分求解收敛

$$
u_{i, j}^{n+1}=u_{i, j}^n+\frac{\Delta t}{\Delta^2}\left(u_{i+1, j}^n+u_{i-1, j}^n+u_{i, j+1}^n+u_{i, j-1}^n-4 u_{i, j}^n\right)
$$

对于最大稳定时间步$$\Delta t=\Delta^2 / 4$$ ，导出雅可比方法

$$
u_{i, j}^{n+1}=\frac{1}{4}\left(u_{i+1, j}^n+u_{i-1, j}^n+u_{i, j+1}^n+u_{i, j-1}^n\right)
$$

这相当于用最近邻的平均值替换每个网格值。这与调和函数理论是一致的。

```python
 def jacobi(grid):
     newgrid = np.zeros(shape=grid.shape,dtype=grid.dtype)
 ​
     newgrid[1:-1,1:-1] = 0.25 * (grid[1:-1,:-2] + grid[1:-1,2:] +
                                  grid[:-2,1:-1] + grid[2:,1:-1])
 ​
     
     newgrid[0,:]  = grid[0,:]
     newgrid[-1,:] = grid[-1,:]
     newgrid[:,0]  = grid[:,0]
     newgrid[:,-1] = grid[:,-1]
     
     return newgrid
```

我们从随机配置开始，应用边界条件，然后迭代。我们间歇性地绘制解，结果显示它收敛了。
