用于光纤耦合仿真的MATLAB程序包

用于光纤耦合仿真的MATLAB程序包,包含模式分布计算和耦合损耗分析功能。程序基于光纤波动方程和模式耦合理论实现。

%% 光纤耦合仿真工具箱
classdef FiberCouplingToolbox
    properties
        lambda = 1550e-9;      % 波长 (m)
        n_core = 1.46;         % 纤芯折射率
        n_clad = 1.45;         % 包层折射率
        core_diameter = 9e-6;   % 纤芯直径 (m)
        NA = 0.12;             % 数值孔径
        length = 1;            % 光纤长度 (m)
    end
    
    methods
        % 构造函数
        function obj = FiberCouplingToolbox(params)
            if nargin > 0
                fields = fieldnames(params);
                for i = 1:length(fields)
                    if isprop(obj, fields{i})
                        obj.(fields{i}) = params.(fields{i});
                    end
                end
            end
        end
        
        %% ========== 模式分布计算 ==========
        function [modes, beta] = calculateModes(obj, max_modes)
            % 计算光纤支持的模式
            % 输入: max_modes - 最大模式数
            % 输出: modes - 模式场分布
            %       beta - 传播常数
            
            % 计算V参数
            V = obj.calculateV();
            
            % 计算支持的模式数
            num_modes = min(max_modes, floor(V^2/4));
            
            % 初始化
            r = linspace(0, obj.core_diameter/2, 100);
            modes = zeros(length(r), num_modes);
            beta = zeros(1, num_modes);
            
            % 计算每个模式的场分布
            for m = 1:num_modes
                [modes(:, m), beta(m)] = obj.calculateLPmode(m);
            end
        end
        
        function V = calculateV(obj)
            % 计算光纤V参数
            V = (2*pi/obj.lambda) * (obj.core_diameter/2) * obj.NA;
        end
        
        function [field, beta] = calculateLPmode(obj, mode_order)
            % 计算特定LP模式场分布
            % 输入: mode_order - 模式阶数 (1=LP01, 2=LP11, ...)
            % 输出: field - 径向场分布
            %       beta - 传播常数
            
            % 光纤参数
            a = obj.core_diameter/2; % 纤芯半径
            k0 = 2*pi/obj.lambda;    % 波数
            
            % 计算V参数
            V = obj.calculateV();
            
            % 计算特征方程
            u = fzero(@(u) obj.modeEquation(u, V, mode_order), [0, V]);
            w = sqrt(V^2 - u^2);
            
            % 计算传播常数
            beta = sqrt(k0^2 * obj.n_core^2 - (u/a)^2);
            
            % 计算场分布
            r = linspace(0, 3*a, 100); % 径向坐标
            
            % 纤芯内场分布 (J_m)
            r_core = r(r <= a);
            field_core = besselj(mode_order-1, u*r_core/a);
            
            % 包层内场分布 (K_m)
            r_clad = r(r > a);
            field_clad = besselj(mode_order-1, u) * ...
                         besselk(mode_order-1, w*r_clad/a) / ...
                         besselk(mode_order-1, w);
            
            % 组合场分布
            field = [field_core, field_clad];
            field = field / max(abs(field)); % 归一化
        end
        
        function eq = modeEquation(~, u, V, m)
            % 光纤模式特征方程
            w = sqrt(V^2 - u^2);
            J = besselj(m-1, u);
            K = besselk(m-1, w);
            dJ = (besselj(m-2, u) - besselj(m, u))/2;
            dK = -(besselk(m-2, w) + besselk(m, w))/2;
            
            eq = u * dJ * K + w * J * dK;
        end
        
        %% ========== 耦合损耗计算 ==========
        function eta = couplingEfficiency(obj, source_field, misalign)
            % 计算光纤耦合效率
            % 输入: source_field - 光源场分布 [x,y,Ex,Ey]
            %       misalign - 失准参数结构体
            % 输出: eta - 耦合效率 (0-1)
            
            % 获取光纤基模
            [fiber_mode, ~] = obj.calculateLPmode(1);
            
            % 提取坐标
            x = source_field(:,1);
            y = source_field(:,2);
            dx = x(2) - x(1);
            dy = y(2) - y(1);
            
            % 应用失准
            if nargin > 2
                source_field = obj.applyMisalignment(source_field, misalign);
            end
            
            % 计算重叠积分
            num = abs(trapz(y, trapz(x, source_field(:,3) .* conj(fiber_mode))).^2;
            denom = trapz(y, trapz(x, abs(source_field(:,3)).^2) .* ...
                    trapz(y, trapz(x, abs(fiber_mode)).^2);
            
            eta = num / denom;
        end
        
        function source_field = applyMisalignment(~, source_field, misalign)
            % 应用失准参数
            % 输入: source_field - 光源场分布 [x,y,Ex,Ey]
            %       misalign - 失准参数结构体
            % 输出: 失准后的场分布
            
            x = source_field(:,1);
            y = source_field(:,2);
            Ex = source_field(:,3);
            
            % 横向偏移
            if isfield(misalign, 'offset_x')
                Ex = interp1(x, Ex, x - misalign.offset_x, 'linear', 0);
            end
            
            % 角度偏移
            if isfield(misalign, 'angle_x')
                k = 2*pi / 1550e-9; % 波数
                phase_tilt = exp(1i*k*sin(misalign.angle_x)*x);
                Ex = Ex .* phase_tilt;
            end
            
            % 轴向偏移
            if isfield(misalign, 'z_distance')
                % 简化的高斯光束传播模型
                w0 = 5e-6; % 假设光源束腰半径
                w_z = w0 * sqrt(1 + (misalign.z_distance * lambda/(pi*w0^2))^2);
                Ex = Ex * w0/w_z .* exp(-(x.^2)/w_z^2);
            end
            
            source_field(:,3) = Ex;
        end
        
        %% ========== 可视化工具 ==========
        function plotModeField(obj, mode_order)
            % 绘制模式场分布
            [field, ~] = obj.calculateLPmode(mode_order);
            a = obj.core_diameter/2;
            r = linspace(0, 3*a, length(field));
            
            figure;
            plot(r*1e6, abs(field).^2, 'LineWidth', 2);
            hold on;
            plot([a*1e6, a*1e6], [0, 1], 'r--', 'LineWidth', 1.5);
            title(sprintf('LP_{%d%d} 模式强度分布', floor((mode_order-1)/2), mod(mode_order-1,2)));
            xlabel('径向距离 (\mum)');
            ylabel('归一化强度');
            legend('模式分布', '纤芯边界');
            grid on;
            set(gca, 'FontSize', 12);
        end
        
        function plot3DMode(obj, mode_order)
            % 绘制3D模式分布
            a = obj.core_diameter/2;
            [x, y] = meshgrid(linspace(-3*a, 3*a, 100));
            r = sqrt(x.^2 + y.^2);
            
            % 获取径向分布
            [field_radial, ~] = obj.calculateLPmode(mode_order);
            r_vec = linspace(0, 3*a, length(field_radial));
            field = interp1(r_vec, field_radial, r, 'linear', 0);
            
            figure;
            surf(x*1e6, y*1e6, abs(field).^2, 'EdgeColor', 'none');
            title(sprintf('LP_{%d%d} 模式3D分布', floor((mode_order-1)/2), mod(mode_order-1,2)));
            xlabel('x (\mum)');
            ylabel('y (\mum)');
            zlabel('强度');
            colormap('jet');
            colorbar;
            axis equal;
            view(3);
            set(gca, 'FontSize', 12);
        end
        
        function plotCouplingVsParameter(obj, param_range, param_name)
            % 绘制耦合效率随参数变化
            % 创建高斯光源
            [x, y] = meshgrid(linspace(-10e-6, 10e-6, 100));
            w0 = 5e-6; % 光源束腰半径
            Ex = exp(-(x.^2 + y.^2)/w0^2);
            source_field = [x(:), y(:), Ex(:)];
            
            efficiencies = zeros(size(param_range));
            
            for i = 1:length(param_range)
                misalign = struct();
                misalign.(param_name) = param_range(i);
                
                % 克隆对象并修改参数
                current_obj = obj;
                if strcmp(param_name, 'core_diameter')
                    current_obj.core_diameter = param_range(i);
                end
                
                efficiencies(i) = current_obj.couplingEfficiency(source_field, misalign);
            end
            
            figure;
            plot(param_range, 10*log10(efficiencies), 'LineWidth', 2);
            xlabel(param_name);
            ylabel('耦合损耗 (dB)');
            title(['耦合效率 vs ' strrep(param_name, '_', ' ')]);
            grid on;
            set(gca, 'FontSize', 12);
        end
    end
end

使用

1. 计算并可视化光纤模式分布

% 创建光纤对象
fiber_params = struct(...
    'lambda', 1550e-9, ...
    'core_diameter', 9e-6, ...
    'n_core', 1.46, ...
    'n_clad', 1.45);
fiber = FiberCouplingToolbox(fiber_params);

% 计算并绘制LP01模式
fiber.plotModeField(1);

% 绘制LP11模式3D分布
fiber.plot3DMode(2);

2. 计算耦合损耗

% 创建光源场分布
[x, y] = meshgrid(linspace(-15e-6, 15e-6, 200));
w0 = 5e-6; % 光源束腰半径
Ex = exp(-(x.^2 + y.^2)/w0^2);
source_field = [x(:), y(:), Ex(:)];

% 定义失准参数
misalign = struct(...
    'offset_x', 1e-6, ...   % 1μm横向偏移
    'angle_x', deg2rad(1), ... % 1度角度偏移
    'z_distance', 10e-6);   % 10μm轴向距离

% 计算耦合效率
eta = fiber.couplingEfficiency(source_field, misalign);
loss_db = -10*log10(eta);
fprintf('耦合效率: %.2f%%, 损耗: %.2f dB\n', eta*100, loss_db);

3. 分析不同芯径的耦合损耗

% 分析不同芯径的耦合损耗
core_diameters = linspace(1e-6, 20e-6, 50);
fiber.plotCouplingVsParameter(core_diameters, 'core_diameter');

参考工具包 光纤耦合仿真MATLAB程序包 www.youwenfan.com/contentcne/80400.html

详解

  1. 光纤模式计算

    • 基于LP模式近似理论
    • 求解光纤特征方程
    • 计算模式场分布和传播常数
    • 支持可视化模式分布
  2. 耦合损耗分析

    • 计算模式重叠积分
    • 支持多种失准类型:
      • 横向偏移
      • 角度偏移
      • 轴向距离
    • 可扩展其他失准因素(端面反射、模式失配等)
  3. 可视化工具

    • 2D模式分布图
    • 3D模式分布图
    • 耦合损耗参数分析

理论基础

  1. 光纤模式计算

    • V参数:\(V = \frac{2\pi a}{\lambda} \text{NA}\)
    • 特征方程:\(u \frac{J_{m-1}(u)}{J_m(u)} = w \frac{K_{m-1}(w)}{K_m(w)}\)
    • 场分布:
      \(\psi(r) = \begin{cases} J_m(u r/a) & r \leq a \\ J_m(u) \frac{K_m(w r/a)}{K_m(w)} & r > a \end{cases}\)
  2. 耦合效率计算

    • 模式重叠积分:
      \(\eta = \frac{\left| \iint E_1 E_2^* dx dy \right|^2}{\iint |E_1|^2 dx dy \cdot \iint |E_2|^2 dx dy}\)
    • 失准影响:
      • 横向偏移:相位不变,振幅偏移
      • 角度偏移:线性相位倾斜
      • 轴向距离:光束扩散
posted @ 2025-08-25 16:23  小前端攻城狮  阅读(48)  评论(0)    收藏  举报