基于主从博弈的主动配电网阻塞管理：MATLAB实现

一、问题背景与核心思想

1. 主动配电网阻塞问题

随着分布式电源（光伏、风电）、电动汽车、储能等灵活性资源大量接入，传统配电网从单向无源网络 转变为双向有源网络，导致线路潮流方向多变、电压波动加剧，极易引发线路阻塞和节点电压越限。

2. 主从博弈（Stackelberg Game）框架

• 领导者（Leader）：配电网系统运营商（DSO）或负荷聚合商（LA），优先决策电价或调度指令。
• 跟随者（Follower）：分布式电源（DG）、可中断负荷（IL）、电动汽车（EV）等资源，根据领导者决策调整自身出力/用电计划。
• 博弈均衡：双方通过多次交互达到Stackelberg均衡，实现全局最优。

3. MATLAB实现核心思路

1. 双层模型构建：上层最小化用户用电成本，下层最大化社会福利。
2. 问题转化：利用KKT条件和对偶定理将非线性双层问题转化为单层混合整数线性规划（MILP）。
3. 算法选择 ：可采用自适应粒子群算法（APSO） 或商业求解器（如Gurobi、CPLEX） 求解。

二、数学模型

1. 符号定义

符号	含义	单位
CLAC^{LA}CLA	负荷聚合商总成本	元
CgridC^{grid}Cgrid	向上级电网购电成本	元
CDGC^{DG}CDG	分布式发电成本	元
CILC^{IL}CIL	可中断负荷补偿成本	元
λt\lambda_tλt	t时段节点边际电价	元/kWh
PtgridP_{t}^{grid}Ptgrid	t时段购电功率	kW
PtDGP_{t}^{DG}PtDG	t时段DG出力	kW
PtILP_{t}^{IL}PtIL	t时段中断负荷量	kW
PtEVP_{t}^{EV}PtEV	t时段EV充电功率	kW
Ui,tU_{i,t}Ui,t	节点i在t时段电压	p.u.
Il,tI_{l,t}Il,t	线路l在t时段电流	A

2. 上层模型：负荷聚合商成本最小化

min⁡CLA=∑t=1T(Cgrid(Ptgrid)+CDG(PtDG)+CIL(PtIL))\min C^{LA} = \sum_{t=1}^{T} \left( C^{grid}(P_{t}^{grid}) + C^{DG}(P_{t}^{DG}) + C^{IL}(P_{t}^{IL}) \right)minCLA=t=1∑T(Cgrid(Ptgrid)+CDG(PtDG)+CIL(PtIL))

约束条件：

1. 功率平衡 ：Ptgrid+PtDG=Ptload−PtIL+PtEVP_{t}^{grid} + P_{t}^{DG} = P_{t}^{load} - P_{t}^{IL} + P_{t}^{EV}Ptgrid+PtDG=Ptload−PtIL+PtEV
2. DG出力约束 ：PminDG≤PtDG≤PmaxDGP_{min}^{DG} \leq P_{t}^{DG} \leq P_{max}^{DG}PminDG≤PtDG≤PmaxDG
3. 可中断负荷约束 ：0≤PtIL≤PmaxIL0 \leq P_{t}^{IL} \leq P_{max}^{IL}0≤PtIL≤PmaxIL
4. EV充电约束 ：∑tPtEV=EEVreq\sum_{t} P_{t}^{EV} = E_{EV}^{req}∑tPtEV=EEVreq

3. 下层模型：配电网运营商社会福利最大化

max⁡SW=∑t=1T(∑iBi,t(Pi,t)−Cgrid(Ptgrid)−CDG(PtDG))\max SW = \sum_{t=1}^{T} \left( \sum_{i} B_{i,t}(P_{i,t}) - C^{grid}(P_{t}^{grid}) - C^{DG}(P_{t}^{DG}) \right)maxSW=t=1∑T(i∑Bi,t(Pi,t)−Cgrid(Ptgrid)−CDG(PtDG))

约束条件：

1. 潮流方程（DistFlow模型） ：
   Pij,t=∑k:j→kPjk,t+rijIij,t2+Pj,tloadP_{ij,t} = \sum_{k:j→k} P_{jk,t} + r_{ij}I_{ij,t}^2 + P_{j,t}^{load}Pij,t=k:j→k∑Pjk,t+rijIij,t2+Pj,tload
   Qij,t=∑k:j→kQjk,t+xijIij,t2+Qj,tloadQ_{ij,t} = \sum_{k:j→k} Q_{jk,t} + x_{ij}I_{ij,t}^2 + Q_{j,t}^{load}Qij,t=k:j→k∑Qjk,t+xijIij,t2+Qj,tload
   Uj,t=Ui,t−2(rijPij,t+xijQij,t)+(rij2+xij2)Iij,t2U_{j,t} = U_{i,t} - 2(r_{ij}P_{ij,t} + x_{ij}Q_{ij,t}) + (r_{ij}^2+x_{ij}^2)I_{ij,t}^2Uj,t=Ui,t−2(rijPij,t+xijQij,t)+(rij2+xij2)Iij,t2
   Iij,t2=Pij,t2+Qij,t2Ui,tI_{ij,t}^2 = \frac{P_{ij,t}^2+Q_{ij,t}^2}{U_{i,t}}Iij,t2=Ui,tPij,t2+Qij,t2

2. 安全约束：

   • 电压约束 ：Umin≤Ui,t≤UmaxU_{min} \leq U_{i,t} \leq U_{max}Umin≤Ui,t≤Umax
   • 线路容量约束 ：Il,t≤IlmaxI_{l,t} \leq I_{l}^{max}Il,t≤Ilmax
   • 变压器容量约束 ：Ptgrid≤StransmaxP_{t}^{grid} \leq S_{trans}^{max}Ptgrid≤Stransmax

4. 主从博弈均衡条件

通过KKT条件将下层问题转化为上层约束：

1. 原始可行性：下层约束全部满足。
2. 对偶可行性：拉格朗日乘子非负。
3. 互补松弛条件： \\mu_{i,t}(U_{i,t} - U_{max}) = 0 等。
4. 平稳性条件 ：∇L=0\nabla L = 0∇L=0。

转化后的单层MILP问题 ：
min⁡CLA\min C^{LA}minCLA

s.t. 上层约束 + 下层KKT条件

三、MATLAB实现框架

1. 整体程序结构

主从博弈主动配电网阻塞管理/
├── main.m                    % 主程序入口
├── data/                     % 数据文件夹
│   ├── IEEE33bus.mat        % IEEE 33节点数据
│   ├── load_profile.mat     % 负荷曲线
│   └── DG_profile.mat       % DG出力曲线
├── model/                    % 模型定义
│   ├── upper_model.m        % 上层模型
│   ├── lower_model.m        % 下层模型
│   └── kkt_conditions.m     % KKT条件转化
├── solver/                   % 求解器
│   ├── apso_solver.m        % 自适应粒子群求解
│   ├── milp_solver.m        % MILP求解
│   └── power_flow.m         % 潮流计算
├── visualization/            % 可视化
│   ├── plot_results.m       % 结果绘图
│   └── animate_voltage.m    % 电压动画
└── utils/                    % 工具函数
    ├── data_loader.m        % 数据加载
    └── constraint_check.m   % 约束检查

2. 主程序（main.m）

%% 基于主从博弈的主动配电网阻塞管理 - 主程序
clear; clc; close all;

%% 1. 数据加载与参数设置
disp('=== 基于主从博弈的主动配电网阻塞管理 ===');
disp('1. 加载系统数据...');

% 加载IEEE 33节点系统数据
load('data/IEEE33bus.mat', 'bus', 'branch', 'baseMVA');
load('data/load_profile.mat', 'P_load', 'Q_load');  % 24小时负荷曲线
load('data/DG_profile.mat', 'P_DG_max', 'cost_DG'); % DG参数

% 仿真参数
T = 24;                     % 时间周期数（24小时）
N_bus = length(bus);        % 节点数
N_branch = length(branch);  % 支路数

% 电价参数（分时电价）
price_grid = [0.35*ones(1,8), 0.65*ones(1,8), 0.85*ones(1,8)]; % 元/kWh
price_IL = 1.2;             % 可中断负荷补偿价格（元/kWh）

% 安全约束
U_min = 0.95; U_max = 1.05; % 电压上下限（p.u.）
I_max = branch(:,6)/baseMVA; % 线路电流上限（p.u.）

%% 2. 主从博弈求解
disp('2. 主从博弈求解...');

% 方法选择：1-KKT转化法，2-迭代法
method = 1;

if method == 1
    % 方法1：KKT转化法（转化为单层MILP）
    [x_opt, fval, exitflag] = solve_by_KKT(T, N_bus, N_branch, ...
        bus, branch, P_load, Q_load, P_DG_max, cost_DG, ...
        price_grid, price_IL, U_min, U_max, I_max);
    
elseif method == 2
    % 方法2：迭代法（自适应粒子群）
    [x_opt, convergence] = solve_by_iteration(T, N_bus, N_branch, ...
        bus, branch, P_load, Q_load, P_DG_max, cost_DG, ...
        price_grid, price_IL, U_min, U_max, I_max);
end

%% 3. 结果提取与分析
disp('3. 分析优化结果...');

% 提取优化变量
P_grid = x_opt.P_grid;      % 购电功率
P_DG = x_opt.P_DG;          % DG出力
P_IL = x_opt.P_IL;          % 可中断负荷
U = x_opt.U;                % 节点电压
I = x_opt.I;                % 线路电流
LMP = x_opt.LMP;            % 节点边际电价

% 计算总成本
total_cost = sum(price_grid .* P_grid + cost_DG .* P_DG + price_IL .* P_IL);
disp(['总运行成本：', num2str(total_cost), ' 元']);

% 检查约束违反
[violation_flag, violation_info] = check_constraints(U, I, U_min, U_max, I_max);
if violation_flag
    disp('警告：存在约束违反！');
    disp(violation_info);
else
    disp('所有约束均满足！');
end

%% 4. 可视化结果
disp('4. 生成可视化图表...');
plot_results(T, P_grid, P_DG, P_IL, U, I, LMP);

%% 5. 场景对比分析
disp('5. 场景对比分析...');
compare_scenarios();

3. KKT转化求解函数（solve_by_KKT.m）

function [x_opt, fval, exitflag] = solve_by_KKT(T, N_bus, N_branch, ...
    bus, branch, P_load, Q_load, P_DG_max, cost_DG, ...
    price_grid, price_IL, U_min, U_max, I_max)
% 通过KKT条件将双层问题转化为单层MILP求解
    
    % 使用YALMIP建模
    yalmip('clear');
    
    % 定义决策变量
    P_grid = sdpvar(T, 1);          % 购电功率
    P_DG = sdpvar(T, N_bus);        % DG出力（每个节点）
    P_IL = sdpvar(T, N_bus);        % 可中断负荷
    U = sdpvar(T, N_bus);           % 节点电压
    Pij = sdpvar(T, N_branch);      % 支路有功
    Qij = sdpvar(T, N_branch);      % 支路无功
    I2 = sdpvar(T, N_branch);       % 支路电流平方
    
    % 定义对偶变量（用于KKT条件）
    lambda_P = sdpvar(T, N_bus);    % 有功平衡对偶变量
    lambda_Q = sdpvar(T, N_bus);    % 无功平衡对偶变量
    mu_Umin = sdpvar(T, N_bus);     % 电压下限对偶变量
    mu_Umax = sdpvar(T, N_bus);     % 电压上限对偶变量
    mu_Imin = sdpvar(T, N_branch);  % 电流下限对偶变量
    mu_Imax = sdpvar(T, N_branch);  % 电流上限对偶变量
    
    % 目标函数：上层成本最小化
    objective = sum(price_grid .* P_grid) + ...
                sum(sum(cost_DG .* P_DG)) + ...
                sum(sum(price_IL .* P_IL));
    
    % 约束集合
    constraints = [];
    
    %% 上层约束
    % 功率平衡约束
    for t = 1:T
        for i = 1:N_bus
            constraints = [constraints, 
                P_grid(t) + P_DG(t,i) == P_load(t,i) - P_IL(t,i)];
        end
    end
    
    % DG出力约束
    constraints = [constraints, 0 <= P_DG <= P_DG_max];
    
    % 可中断负荷约束
    constraints = [constraints, 0 <= P_IL <= 0.2 * P_load]; % 最大中断20%
    
    % 购电功率约束
    constraints = [constraints, 0 <= P_grid <= 2000]; % kW
    
    %% 下层KKT条件（通过DistFlow模型）
    % 潮流方程约束
    for t = 1:T
        for k = 1:N_branch
            i = branch(k,1); j = branch(k,2);
            r = branch(k,3); x = branch(k,4);
            
            % DistFlow方程
            constraints = [constraints,
                Pij(t,k) == sum(Pij(t, branch(:,1)==j)) + r*I2(t,k) + P_load(t,j) - P_DG(t,j) + P_IL(t,j)];
            constraints = [constraints,
                Qij(t,k) == sum(Qij(t, branch(:,1)==j)) + x*I2(t,k) + Q_load(t,j))];
            constraints = [constraints,
                U(t,j) == U(t,i) - 2*(r*Pij(t,k) + x*Qij(t,k)) + (r^2+x^2)*I2(t,k)];
            constraints = [constraints,
                I2(t,k) == (Pij(t,k)^2 + Qij(t,k)^2) / U(t,i)];
        end
    end
    
    % 根节点电压固定
    constraints = [constraints, U(:,1) == 1.0];
    
    % 安全约束
    constraints = [constraints, U_min <= U <= U_max];
    constraints = [constraints, I2 >= 0];
    constraints = [constraints, I2 <= I_max.^2];
    
    %% KKT条件：平稳性、互补松弛条件
    % 注：此处简化处理，实际需根据下层拉格朗日函数推导
    % 这里展示关键互补松弛条件的线性化方法
    
    % 电压上限互补松弛条件的大M法线性化
    M = 1000; % 大M常数
    binary_Umax = binvar(T, N_bus); % 辅助二进制变量
    
    for t = 1:T
        for i = 1:N_bus
            constraints = [constraints,
                U(t,i) - U_max <= M * (1 - binary_Umax(t,i))];
            constraints = [constraints,
                mu_Umax(t,i) <= M * binary_Umax(t,i)];
            constraints = [constraints,
                mu_Umax(t,i) >= 0];
        end
    end
    
    % 电流上限互补松弛条件类似处理...
    
    %% 求解优化问题
    ops = sdpsettings('solver', 'gurobi', 'verbose', 1, 'debug', 1);
    ops.gurobi.TimeLimit = 300; % 5分钟时间限制
    ops.gurobi.MIPGap = 0.01;   % 1%的MIP间隙
    
    disp('开始求解MILP问题...');
    tic;
    sol = optimize(constraints, objective, ops);
    solve_time = toc;
    
    disp(['求解完成，耗时：', num2str(solve_time), ' 秒']);
    
    %% 提取结果
    if sol.problem == 0
        x_opt.P_grid = value(P_grid);
        x_opt.P_DG = value(P_DG);
        x_opt.P_IL = value(P_IL);
        x_opt.U = value(U);
        x_opt.I = sqrt(value(I2));
        x_opt.LMP = value(lambda_P); % 节点边际电价
        
        fval = value(objective);
        exitflag = 1;
        
        disp('优化成功！');
    else
        warning('求解失败！');
        x_opt = [];
        fval = inf;
        exitflag = 0;
    end
end

4. 自适应粒子群迭代求解（solve_by_iteration.m）

function [x_opt, convergence] = solve_by_iteration(T, N_bus, N_branch, ...
    bus, branch, P_load, Q_load, P_DG_max, cost_DG, ...
    price_grid, price_IL, U_min, U_max, I_max)
% 使用自适应粒子群算法迭代求解主从博弈
    
    %% 参数设置
    max_iter = 50;          % 最大迭代次数
    pop_size = 30;          % 粒子群规模
    tolerance = 1e-3;       % 收敛容差
    
    % 自适应参数
    w_max = 0.9; w_min = 0.4;   % 惯性权重范围
    c1_max = 2.5; c1_min = 1.5; % 个体学习因子
    c2_max = 2.5; c2_min = 1.5; % 社会学习因子
    
    %% 初始化粒子群
    % 上层粒子：电价策略
    upper_swarm = initialize_upper_swarm(pop_size, T, price_grid);
    
    % 下层粒子：资源调度策略
    lower_swarm = initialize_lower_swarm(pop_size, T, N_bus, P_DG_max);
    
    % 历史最佳记录
    global_best.upper = [];
    global_best.lower = [];
    global_best.cost = inf;
    
    convergence.iter = [];
    convergence.cost = [];
    convergence.gap = [];
    
    %% 主迭代循环
    disp('开始主从博弈迭代求解...');
    
    for iter = 1:max_iter
        % 自适应参数调整
        w = w_max - (w_max - w_min) * iter / max_iter;
        c1 = c1_max - (c1_max - c1_min) * iter / max_iter;
        c2 = c2_min + (c2_max - c2_min) * iter / max_iter;
        
        %% 上层优化：给定电价，优化购电和DG调度
        for p = 1:pop_size
            % 当前电价策略
            current_price = upper_swarm(p).position;
            
            % 下层响应：给定电价，优化资源调度
            [lower_response, lower_cost] = solve_lower_problem(...
                current_price, P_load, Q_load, P_DG_max, cost_DG, ...
                bus, branch, U_min, U_max, I_max);
            
            % 计算上层成本
            upper_cost = calculate_upper_cost(current_price, lower_response, ...
                price_grid, price_IL);
            
            % 更新粒子个体最优
            if upper_cost < upper_swarm(p).best_cost
                upper_swarm(p).best_position = current_price;
                upper_swarm(p).best_cost = upper_cost;
                upper_swarm(p).best_lower_response = lower_response;
            end
            
            % 更新全局最优
            if upper_cost < global_best.cost
                global_best.upper = current_price;
                global_best.lower = lower_response;
                global_best.cost = upper_cost;
            end
        end
        
        %% 下层优化反馈，更新上层粒子
        % 计算平均下层成本作为反馈
        avg_lower_cost = mean([upper_swarm.best_cost]);
        
        % 更新上层粒子速度和位置
        for p = 1:pop_size
            % 速度更新
            r1 = rand(size(upper_swarm(p).position));
            r2 = rand(size(upper_swarm(p).position));
            
            upper_swarm(p).velocity = w * upper_swarm(p).velocity + ...
                c1 * r1 .* (upper_swarm(p).best_position - upper_swarm(p).position) + ...
                c2 * r2 .* (global_best.upper - upper_swarm(p).position);
            
            % 位置更新（考虑边界）
            upper_swarm(p).position = upper_swarm(p).position + upper_swarm(p).velocity;
            upper_swarm(p).position = max(0.2, min(1.5, upper_swarm(p).position)); % 电价范围
        end
        
        %% 收敛判断
        if iter > 1
            cost_gap = abs(convergence.cost(end) - global_best.cost) / global_best.cost;
            
            convergence.iter = [convergence.iter, iter];
            convergence.cost = [convergence.cost, global_best.cost];
            convergence.gap = [convergence.gap, cost_gap];
            
            if cost_gap < tolerance
                disp(['迭代收敛于第 ', num2str(iter), ' 代']);
                break;
            end
        end
        
        % 显示进度
        if mod(iter, 5) == 0
            disp(['迭代 ', num2str(iter), '/', num2str(max_iter), ...
                '，当前最优成本：', num2str(global_best.cost)]);
        end
    end
    
    %% 输出最终结果
    x_opt.P_grid = global_best.lower.P_grid;
    x_opt.P_DG = global_best.lower.P_DG;
    x_opt.P_IL = global_best.lower.P_IL;
    x_opt.U = global_best.lower.U;
    x_opt.I = global_best.lower.I;
    x_opt.LMP = global_best.upper;
    
    disp(['最终优化成本：', num2str(global_best.cost), ' 元']);
end

5. 可视化函数（plot_results.m）

function plot_results(T, P_grid, P_DG, P_IL, U, I, LMP)
% 绘制优化结果图表
    
    figure('Position', [100, 100, 1200, 800]);
    
    %% 子图1：功率平衡
    subplot(3,3,1);
    t = 1:T;
    area(t, [P_DG', P_IL', P_grid' - P_DG' - P_IL']);
    legend('DG出力', '可中断负荷', '净购电', 'Location', 'best');
    xlabel('时间 (h)'); ylabel('功率 (kW)');
    title('功率平衡图');
    grid on;
    
    %% 子图2：节点电压分布
    subplot(3,3,2);
    imagesc(1:T, 1:size(U,2), U');
    colorbar;
    xlabel('时间 (h)'); ylabel('节点编号');
    title('节点电压分布 (p.u.)');
    clim([0.95, 1.05]);
    
    %% 子图3：线路负载率
    subplot(3,3,3);
    I_load_rate = I ./ max(I,[],2);
    plot(1:T, I_load_rate', 'LineWidth', 1.5);
    xlabel('时间 (h)'); ylabel('负载率');
    title('线路负载率');
    grid on;
    legend('线路1', '线路2', '线路3', 'Location', 'best');
    
    %% 子图4：节点边际电价
    subplot(3,3,4);
    plot(1:T, LMP, 'LineWidth', 2);
    xlabel('时间 (h)'); ylabel('电价 (元/kWh)');
    title('节点边际电价');
    grid on;
    
    %% 子图5：成本构成
    subplot(3,3,5);
    cost_grid = sum(P_grid .* LMP);
    cost_DG = sum(sum(P_DG .* 0.4)); % 假设DG成本0.4元/kWh
    cost_IL = sum(sum(P_IL .* 1.2));
    pie([cost_grid, cost_DG, cost_IL]);
    legend({'购电成本', 'DG成本', '中断补偿'}, 'Location', 'best');
    title('成本构成');
    
    %% 子图6：阻塞情况
    subplot(3,3,6);
    congestion_lines = find(any(I_load_rate > 0.9, 2));
    bar(congestion_lines, max(I_load_rate(congestion_lines,:), [], 2));
    xlabel('线路编号'); ylabel('最大负载率');
    title('阻塞线路识别');
    grid on;
    ylim([0.8, 1.1]);
    
    %% 子图7：电压越限统计
    subplot(3,3,7);
    U_violation = sum(U < 0.95 | U > 1.05, 2);
    bar(1:T, U_violation);
    xlabel('时间 (h)'); ylabel('越限节点数');
    title('电压越限统计');
    grid on;
    
    %% 子图8：DG渗透率
    subplot(3,3,8);
    DG_penetration = sum(P_DG, 2) ./ sum(P_grid + sum(P_DG, 2), 2) * 100;
    plot(1:T, DG_penetration, 'LineWidth', 2);
    xlabel('时间 (h)'); ylabel('渗透率 (%)');
    title('DG渗透率');
    grid on;
    
    %% 子图9：博弈收敛过程
    subplot(3,3,9);
    % 假设有收敛历史数据
    if exist('convergence_history.mat', 'file')
        load('convergence_history.mat');
        semilogy(convergence.iter, convergence.gap, 'LineWidth', 2);
        xlabel('迭代次数'); ylabel('成本间隙');
        title('博弈收敛过程');
        grid on;
    end
    
    sgtitle('基于主从博弈的主动配电网阻塞管理优化结果');
end

参考代码 基于主从博弈的主动配电网阻塞管理 www.youwenfan.com/contentcst/160590.html

四、关键技术与注意事项

1. 潮流模型选择

• DistFlow模型：适用于辐射状配电网，精度高但非线性强。
• LinDistFlow模型：线性化近似，计算速度快，适合大规模问题。
• ZIP负荷模型：考虑电压相关负荷，更贴近实际。

2. 求解器选择建议

求解器	适用问题	优点	缺点
Gurobi	MILP/MIQP	速度快，稳定性好	商业软件需授权
CPLEX	MILP	工业级求解器	商业授权
YALMIP+IPOPT	NLP	开源免费	可能收敛慢
MATLAB fmincon	中小规模NLP	易用，集成好	全局优化能力弱

3. 收敛性保障策略

1. 初始点选择：使用历史最优解或典型场景解作为初始点。
2. 自适应参数：迭代过程中动态调整算法参数。
3. 多起点优化：从多个初始点开始，避免局部最优。
4. 可行性修复：对不可行解进行修复，保证迭代连续性。

4. 实际工程考虑

• 通信延迟：主从博弈需要多次信息交换，需考虑通信时延影响。
• 不确定性处理：负荷和DG出力的不确定性可通过场景法或鲁棒优化处理。
• 实时性要求：在线应用需保证求解时间<5分钟。
• 隐私保护：用户数据隐私需通过分布式算法保护。

五、扩展应用

1. 多时间尺度协调

• 日前调度：主从博弈确定24小时计划。
• 日内滚动：每15分钟调整，应对实时波动。
• 实时控制：秒级响应，保障电压稳定。

2. 多主体博弈

考虑更多博弈参与者：

• 多个负荷聚合商竞争资源。
• 分布式储能运营商参与市场。
• 电动汽车聚合商提供调频服务。

3. 与电力市场衔接

• 节点边际电价（LMP） 作为博弈价格信号。
• 阻塞盈余分配 机制设计。
• 市场力抑制 策略。

六、总结

基于主从博弈的主动配电网阻塞管理通过双层优化框架 ，实现了经济性 与安全性的平衡。MATLAB实现的关键在于：

1. 准确建模：选择合适的潮流模型和安全约束。
2. 高效求解：KKT转化法适合中小规模问题，迭代法适合复杂非线性问题。
3. 实用验证：在IEEE标准算例上测试，确保算法有效性。
4. 工程适配：考虑实际通信、计算、不确定性等因素。