Python(TensorFlow)多模光纤光束算法和GPU并行模拟

🎯要点

🎯多模光纤包含光学系统线性和非线性部分 | 🎯单变量线性回归、多变量线性回归、人脸图像年龄预测、音频语音分类和 X 射线图像评估算法 | 🎯在空间光调制器记录海螺参数矩阵，光束算法多变量预测年龄 | 🎯光束算法数学模型

📜光学和散射用例

🍪语言内容分比

🍇Python光泵浦

光泵浦还用于将原子或分子内束缚的电子循环泵浦至明确的量子态。对于包含单个外壳电子的原子种类的相干两能级光泵浦的最简单情况，这意味着电子被相干泵浦到单个超精细子能级（标记为 m F m_F mF ），这是由泵浦激光器以及量子选择规则。在光泵浦时，据说原子在特定的 m F m_F mF 子能级中定向，然而，由于光泵浦的循环性质，束缚电子实际上会在上能级和下能级之间经历重复的激发和衰变。泵浦激光器的频率和偏振决定了原子取向的 m F m_F mF子能级。

实际上，由于跃迁线宽的功率加宽以及超精细结构捕获和辐射捕获等不良影响，完全相干光泵浦可能不会发生。因此，原子的方向更一般地取决于激光的频率、强度、偏振和光谱带宽以及吸收跃迁的线宽和跃迁概率。

我们首先定义激光束、哈密顿量和磁场。在这里，我们感兴趣的是线偏振光下的 F = 2 → F ′ = 3 F=2 \rightarrow F^{\prime}=3 F=2→F′=3 跃迁。我们制作了三种激光束组合，每种组合都具有沿不同轴的线性偏振。请注意，只有在单激光束的情况下，速率方程和光学布洛赫方程才会一致。这是因为速率方程假设激光是不相干的（它们的电场不会相加得到两倍的振幅），而光学布洛赫方程则假设激光是不相干的。具体来说，两个相干光束使电场加倍，从而使强度四极，因此为了比较速率方程，我们必须乘以 4 。我们对 π y \pi_y πy 和 π z \pi_z πz 极化执行此操作。对于 π x \pi_x πx 光束，我们将其分成两个光束。

最后，可以将失谐置于激光器上或将失谐置于哈密顿量上（或两者的某种组合）。后者似乎更快。

gamma = 1 

laserBeams = {}
laserBeams['$\\pi_z$']= pyp.laserBeams([
    {'kvec': np.array([1., 0., 0.]), 'pol':np.array([0., 0., 1.]),
     'pol_coord':'cartesian', 'delta':-2.73*gamma, 's':4*0.16*(1+2.73**2)}
    ])
laserBeams['$\\pi_y$']= pyp.laserBeams([
    {'kvec': np.array([0., 0., 1.]), 'pol':np.array([0., 1., 0.]),
     'pol_coord':'cartesian', 'delta':-2.73*gamma, 's':4*0.16*(1+2.73**2)}
    ])
laserBeams['$\\pi_x$']= pyp.laserBeams([
    {'kvec': np.array([0., 0., 1.]), 'pol':np.array([1., 0., 0.]),
     'pol_coord':'cartesian', 'delta':-2.73*gamma, 's':0.16*(1+2.73**2)},
    {'kvec': np.array([0., 0., -1.]), 'pol':np.array([1., 0., 0.]),
     'pol_coord':'cartesian', 'delta':-2.73*gamma, 's':0.16*(1+2.73**2)}
    ])

magField = lambda R: np.zeros(R.shape)

H_g, muq_g = pyp.hamiltonians.singleF(F=2, gF=1, muB=1)
H_e, mue_q = pyp.hamiltonians.singleF(F=3, gF=1, muB=1)
d_q = pyp.hamiltonians.dqij_two_bare_hyperfine(2, 3)
hamiltonian = pyp.hamiltonian()
hamiltonian.add_H_0_block('g', H_g)
hamiltonian.add_H_0_block('e', H_e-0.*np.eye(H_e.shape[0]))
hamiltonian.add_d_q_block('g', 'e', d_q, gamma=gamma)

hamiltonian.print_structure()

计算密度迁移

obe = {}
rateeq = {}
rateeq['$\\pi_z$'] = pyp.rateeq(laserBeams['$\\pi_z$'], magField,
                                  hamiltonian)
obe['$\\pi_z$'] = pyp.obe(laserBeams['$\\pi_z$'], magField, hamiltonian,
                            transform_into_re_im=transform)

N0 = np.zeros((rateeq['$\\pi_z$'].hamiltonian.n,))
N0[0] = 1
rateeq['$\\pi_z$'].set_initial_pop(N0)
rateeq['$\\pi_z$'].evolve_populations([0, 600/gamma],
                                      max_step=1/gamma)

rho0 = np.zeros((obe['$\\pi_z$'].hamiltonian.n**2,))
rho0[0] = 1.
obe['$\\pi_z$'].set_initial_rho(np.real(rho0))
obe['$\\pi_z$'].evolve_density(t_span=[0, 600/gamma],
                               progress_bar=True)

Neq = rateeq['$\\pi_z$'].equilibrium_populations(np.array([0., 0., 0.]),
                                                 np.array([0., 0., 0.]), 0.)

绘制结果

fig, ax = plt.subplots(1, 1)
for jj in range(5):
    ax.plot(gamma*rateeq['$\\pi_z$'].sol.t,
            rateeq['$\\pi_z$'].sol.y[jj, :], '--',
            color='C{0:d}'.format(jj),
            linewidth=1.0)
    ax.plot(gamma*obe['$\\pi_z$'].sol.t, np.abs(obe['$\\pi_z$'].sol.rho[jj, jj]), '-',
            color='C{0:d}'.format(jj),
            linewidth=0.5)
    ax.plot(gamma*obe['$\\pi_z$'].sol.t[-1], Neq[jj], '.', color='C{0:d}'.format(jj),
            linewidth=0.5)

ax.set_xlabel('$\\Gamma t$')
ax.set_ylabel('$\\rho_{ii}$');

接下来，我们要检查我们的旋转是否正常工作，因此我们将对具有 π y \pi_y πy 偏振的 z ^ \hat{z} z^ 行进光束进行相同的计算。但在我们使用光学布洛赫方程之前，我们需要首先创建初始状态，这涉及到旋转我们的状态。

mug = spherical2cart(muq_g)
S = -mug

E, U = np.linalg.eig(S[1])
inds = np.argsort(E)
E = E[inds]
U = U[:, inds]
Uinv = np.linalg.inv(U)
psi = U[:, 0]

rho0 = np.zeros((hamiltonian.n, hamiltonian.n), dtype='complex128')
for ii in range(hamiltonian.ns[0]):
    for jj in range(hamiltonian.ns[0]):
        rho0[ii, jj] = psi[ii]*np.conjugate(psi[jj])

obe['$\\pi_y$'] = pyp.obe(laserBeams['$\\pi_y$'], magField, hamiltonian,
                            transform_into_re_im=transform)
obe['$\\pi_y$'].set_initial_rho(rho0.reshape(hamiltonian.n**2,))
obe['$\\pi_y$'].evolve_density(t_span=[0, 600],
                               progress_bar=True)

for jj in range(obe['$\\pi_y$'].sol.t.size):
    obe['$\\pi_y$'].sol.rho[:5, :5, jj] = Uinv@obe['$\\pi_y$'].sol.rho[:5, :5, jj]

绘制结果

fig, ax = plt.subplots(1, 1)
for jj in range(5):
    ax.plot(obe['$\\pi_y$'].sol.t,
            np.abs(obe['$\\pi_y$'].sol.rho[jj, jj]), '-',
            color='C{0:d}'.format(jj),
            linewidth=0.5)
ax.set_xlabel('$\\Gamma t$')
ax.set_ylabel('$\\rho_{ii}$');

现在，让我们对 π x \pi_x πx 做同样的事情，只不过这次我们有两束激光束，强度为 1 / 4 1 / 4 1/4：

E, U = np.linalg.eig(S[0])

inds = np.argsort(E)
E = E[inds]
U = U[:, inds]
Uinv = np.linalg.inv(U)

psi = U[:, 0]

rho0 = np.zeros((hamiltonian.n, hamiltonian.n), dtype='complex128')
for ii in range(hamiltonian.ns[0]):
    for jj in range(hamiltonian.ns[0]):
        rho0[ii, jj] = psi[ii]*np.conjugate(psi[jj])

obe['$\\pi_x$'] = pyp.obe(laserBeams['$\\pi_x$'], magField, hamiltonian,
                            transform_into_re_im=transform)
obe['$\\pi_x$'].set_initial_rho(rho0.reshape(hamiltonian.n**2,))
obe['$\\pi_x$'].evolve_density(t_span=[0, 600],
                               progress_bar=True)

for jj in range(obe['$\\pi_x$'].sol.t.size):
    obe['$\\pi_x$'].sol.rho[:5, :5, jj] = Uinv@obe['$\\pi_x$'].sol.rho[:5, :5, jj]

👉参阅、更新：计算思维 | 亚图跨际