影响单模光纤耦合效率的分析

影响单模光纤耦合效率的因素

如果想使单模光纤的耦合效率最高，入射光束需要满足以下条件：

（1）入射光束接近高斯光；

（2）入射光束从光纤端面正入射；

（3）入射光束的束腰位于光纤端面；

（4）入射光束的束腰中心对准纤芯中心；

（5）入射光束的束腰直径等于单模光纤的MFD（MFD≈1.15d）。

下面仿真当以上条件不满足时，对单模光纤耦合效率的影响。

（1）模式失配损失（Mode mismatching loss）

模式失配，即入射光束的束腰直径不等于单模光纤的MFD，如下图所示：

假设入射光束的束腰位于光纤端面，入射光束的束腰中心与纤芯中心对准且正入射，此时单模光纤的耦合效率为

Python脚本如下：

import numpy as np
import matplotlib.pyplot as plt

# Define the range of the waist - diameter of the incident beam
omega_in = np.linspace(2, 8, 1000) # Range from 2um to 8um, 1000 points
omega_0 = 5.2  # MFD/2 = 5.2um

# Calculate the coupling efficiency
eta = (4 * omega_in ** 2 * omega_0 ** 2) / ((omega_in ** 2 + omega_0 ** 2) ** 2)

# Convert the coupling efficiency to dB
eta_db = 10 * np.log10(eta)

# Plot the graph
plt.plot(omega_in, eta_db)
plt.xlabel('$\omega_{in}$ (um)')
plt.ylabel('Coupling Efficiency (dB)')
plt.title('Simulation of Coupling Efficiency - Mode Fiber')
plt.show()

下图为SMF-28单模光纤耦合模式失配的拟合曲线:

（2）横向失配损失（Lateral Mismatching Loss）

横向失配，即入射光束的束腰中心没有与纤芯中心对准，如下图所示：

此时，假设入射光束的束腰位于光纤端面且正入射，入射光束的束腰直径等于单模光纤的MFD，但是入射光束的束腰中心与纤芯中心横向偏移Δx，此时单模光纤的耦合效率为

Python脚本如下：

import numpy as np
import matplotlib.pyplot as plt

# Define the range of lateral - offset
delta_x = np.linspace(0, 5, 1000) # Range from 0um to 5um, 1000 points
omega_in = 5.2  # Waist - diameter of the incident beam
omega_0 = 5.2  # MFD/2 of the single - mode fiber

# Calculate the coupling efficiency
eta = (4 * omega_in ** 2 * omega_0 ** 2) / ((omega_in ** 2 + omega_0 ** 2) ** 2) * np.exp(-(2 * delta_x ** 2) / (omega_in ** 2 + omega_0 ** 2))

# Convert the coupling efficiency to dB
eta_db = 10 * np.log10(eta)

# Plot the graph
plt.plot(delta_x, eta_db)
plt.xlabel('$\Delta x$ (um)')
plt.ylabel('Coupling Efficiency (dB)')
plt.title('Simulation of Coupling Efficiency - Mode Fiber with Lateral Offset')
plt.show()

下图为SMF-28单模光纤耦合横向失配的拟合曲线:

（3）轴向失配损失（Longitudinal mismatching loss）

轴向失配，即入射光束的束腰中心没有位于光纤端面，如下图所示：

此时，假设入射光束的束腰直径等于单模光纤的MFD，入射光束的束腰中心与纤芯中心横向对准且正入射，但是，入射光束的束腰与光纤端面轴向偏移Δz，此时单模光纤的耦合效率为

Python脚本如下：

import numpy as np
import matplotlib.pyplot as plt

# Wavelength in um, assume 1.55 um which is a common operating wavelength for SMF - 28
lambda_ = 1.55
# Define the range of axial - offset
delta_z = np.linspace(-50, 50, 1000) # Range from - 50um to 50um, 1000 points
omega_in = 5.2  # Waist - diameter of the incident beam
omega_0 = 5.2  # MFD/2 of the single - mode fiber

# Calculate the coupling efficiency
eta = (4 * omega_in ** 2 * omega_0 ** 2) / ((omega_in ** 2 + omega_0 ** 2) ** 2 + (lambda_ * delta_z / np.pi) ** 2)

# Convert the coupling efficiency to dB
eta_db = 10 * np.log10(eta)

# Plot the graph
plt.plot(delta_z, eta_db)
plt.xlabel('$\Delta z$ (um)')
plt.ylabel('Coupling Efficiency (dB)')
plt.title('Simulation of Coupling Efficiency - Mode Fiber with Axial Offset')
plt.show()

下图为SMF-28单模光纤耦合轴向失配的拟合曲线:

（4）角度失配损失（Angular mismatching loss）

角度失配，即入射光束没有从光纤端面正入射，如下图所示：

此时，假设入射光束的束腰直径等于单模光纤的MFD，入射光束的束腰中心与纤芯中心横向对准，但是，入射光束的束腰与光纤端面的夹角为θ，此时单模光纤的耦合效率为

Python脚本如下：

import numpy as np
import matplotlib.pyplot as plt

# Wavelength in um, assume 1.55 um which is a common operating wavelength for SMF - 28
lambda_ = 1.55
# Define the range of the angle theta in degrees
theta_degrees = np.linspace(0, 5, 1000)
# Convert degrees to radians
theta = np.radians(theta_degrees)
omega_in = 5.2
omega_0 = 5.2

# Calculate the coupling efficiency
eta = (4 * omega_in ** 2 * omega_0 ** 2) / (omega_in ** 2 + omega_0 ** 2) ** 2 * np.exp(
-(2 * omega_in ** 2 * omega_0 ** 2) / (omega_in ** 2 + omega_0 ** 2) * (np.pi * theta / lambda_) ** 2)

# Convert the coupling efficiency to dB
eta_db = 10 * np.log10(eta)

# Plot the graph
plt.plot(theta_degrees, eta_db)
plt.xlabel('$\theta$ (degrees)')
plt.ylabel('Coupling Efficiency (dB)')
plt.title('Simulation of Coupling Efficiency - Mode Fiber with Angular Misalignment')
plt.show()

下图为SMF-28单模光纤耦合角度失配的拟合曲线：

（5）单模光纤失配的一般方程

单模光纤的各种失配情况，如下图所示：

此时，假设入射光束的束腰直径不等于单模光纤的MFD，入射光束的束腰中心与纤芯中心横向偏移Δx，入射光束的束腰与光纤端面轴向偏移Δz，入射光束的束腰与光纤端面的夹角为θ，此时单模光纤的耦合效率的一般方程为

上式中，

计算入射光束的束腰半径ω1=4um，入射光束的束腰中心与纤芯中心横向偏移Δx=2um，入射光束的束腰与光纤端面轴向偏移Δz=20um，入射光束的束腰与光纤端面的夹角为θ=1°，ω0=5.2um，SMF-28单模光纤的耦合效率。

Python脚本如下：

import math

# Given parameters
omega1 = 4
delta_x = 2
delta_z = 20
theta = math.pi / 180
omega0 = 5.2
lambda_ = 1.55

# Calculate omega1^2(z)
omega1z_squared = omega1**2 * (1 + (lambda_**2 * delta_z**2) / (math.pi**2 * omega1**4))

# Calculate A
A = (4 * omega1**2 * omega0**2) / ((omega1**2 + omega0**2)**2 + (lambda_**2 * delta_z**2) / math.pi**2)

# Calculate the coupling efficiency eta
term1 = (delta_x**2 / 2) * (1 / omega1**2 + 1 / omega0**2)
term2 = (math.pi**2 * theta**2) / (2 * lambda_**2) * (omega1z_squared + omega0**2)
term3 = (delta_x * theta * delta_z) / omega1**2
eta = A * math.exp(-A * (term1 + term2 - term3))

# Convert to percentage and dB
eta_percent = eta * 100
eta_dB = 10 * math.log10(eta)

print(f"Coupling efficiency (percentage): {eta_percent:.2f}%")
print(f"Coupling efficiency (dB): {eta_dB:.2f} dB")

计算结果为：

（6）生成一个交互界面来计算不同参数下的单模光纤耦合效率

Python脚本如下：

import math
import tkinter as tk
from tkinter import messagebox

def calculate_coupling_efficiency():
try:
        # Get the parameters entered by the user
        omega1 = float(omega1_entry.get())
        delta_x = float(delta_x_entry.get())
        delta_z = float(delta_z_entry.get())
        theta_deg = float(theta_entry.get())
        theta = math.radians(theta_deg)
        omega0 = float(omega0_entry.get())
        lambda_ = float(lambda_entry.get())

        # Calculate omega1^2(z)
        omega1z_squared = omega1**2 * (1 + (lambda_**2 * delta_z**2) / (math.pi**2 * omega1**4))

        # Calculate A
        A = (4 * omega1**2 * omega0**2) / ((omega1**2 + omega0**2)**2 + (lambda_**2 * delta_z**2) / math.pi**2)

        # Calculate the coupling efficiency eta
        term1 = (delta_x**2 / 2) * (1 / omega1**2 + 1 / omega0**2)
        term2 = (math.pi**2 * theta**2) / (2 * lambda_**2) * (omega1z_squared + omega0**2)
        term3 = (delta_x * theta * delta_z) / omega1**2
        eta = A * math.exp(-A * (term1 + term2 - term3))

        # Convert to percentage and dB
        eta_percent = eta * 100
        eta_dB = 10 * math.log10(eta)

        # Display the results
result_label.config(text=f"Coupling efficiency (percentage): {eta_percent:.2f}%\nCoupling efficiency (dB): {eta_dB:.2f} dB")
    except ValueError:
        messagebox.showerror("Input Error", "Please enter valid numerical values for all parameters.")

# Create the main window
root = tk.Tk()
root.title("Single - Mode Fiber Coupling Efficiency Calculator")

# Create labels and input boxes
tk.Label(root, text="ω1 (μm):").grid(row=0, column=0)
omega1_entry = tk.Entry(root)
omega1_entry.grid(row=0, column=1)

tk.Label(root, text="Δx (μm):").grid(row=1, column=0)
delta_x_entry = tk.Entry(root)
delta_x_entry.grid(row=1, column=1)

tk.Label(root, text="Δz (μm):").grid(row=2, column=0)
delta_z_entry = tk.Entry(root)
delta_z_entry.grid(row=2, column=1)

tk.Label(root, text="θ (degrees):").grid(row=3, column=0)
theta_entry = tk.Entry(root)
theta_entry.grid(row=3, column=1)

tk.Label(root, text="ω0 (μm):").grid(row=4, column=0)
omega0_entry = tk.Entry(root)
omega0_entry.grid(row=4, column=1)

tk.Label(root, text="λ (μm):").grid(row=5, column=0)
lambda_entry = tk.Entry(root)
lambda_entry.grid(row=5, column=1)

# Create the calculate button
calculate_button = tk.Button(root, text="Calculate", command=calculate_coupling_efficiency)
calculate_button.grid(row=6, column=0, columnspan=2)

# Create the result label
result_label = tk.Label(root, text="")
result_label.grid(row=7, column=0, columnspan=2)

# Run the main loop
root.mainloop()

交互界面如下图：