微电网两阶段鲁棒优化经济调度MATLAB实现

基于YALMIP工具箱的微电网两阶段鲁棒优化经济调度MATLAB代码

一、系统参数与模型设置

1.1 基本参数定义

matlab 复制代码

clear; clc; close all;

% -------------------------- 系统参数 --------------------------
T = 24;                  % 调度时段（24小时）
PV_cap = 500;             % 光伏容量 (kW)
Wind_cap = 300;           % 风机容量 (kW)
DG_cap = 200;             % 柴油发电机容量 (kW)
ESS_cap = 200;            % 储能容量 (kWh)
ESS_power_max = 50;        % 储能最大充放电功率 (kW)
SOC_min = 0.2;            % 储能最小SOC
SOC_max = 0.9;            % 储能最大SOC
eta_cha = 0.95;            % 储能充电效率
eta_dis = 0.95;            % 储能放电效率
SOC0 = 0.5;                % 初始SOC
C_dg = 0.8;               % 柴油发电机运行成本 (元/kWh)
C_grid_buy = [0.4*ones(1,7), 1.2*ones(1,10), 0.4*ones(1,7)]; % 购电电价 (峰时8-18时1.2元)
C_grid_sell = 0.3;         % 售电电价 (元/kWh)

% -------------------------- 不确定性参数 --------------------------
% 光伏出力预测误差 ±20%，风机 ±15%，负荷 ±10%
PV_pred = [0, 0, 0, 0, 0, 10, 30, 80, 150, 200, 250, 300, 350, 380, 400, 380, 350, 300, 250, 180, 100, 30, 0, 0]; % 预测出力 (kW)
Wind_pred = [120, 130, 140, 150, 160, 170, 180, 190, 200, 190, 180, 170, 160, 150, 140, 130, 120, 110, 100, 90, 80, 70, 60, 50]; % 预测出力 (kW)
Load_pred = [80, 70, 60, 50, 60, 80, 120, 180, 250, 300, 320, 300, 280, 260, 280, 300, 320, 300, 280, 250, 200, 150, 100, 90]; % 预测负荷 (kW)

% 不确定性集合（盒式集合）
PV_min = 0.8 * PV_pred;    % 光伏出力下界
PV_max = 1.2 * PV_pred;    % 光伏出力上界
Wind_min = 0.85 * Wind_pred; % 风机出力下界
Wind_max = 1.15 * Wind_pred; % 风机出力上界
Load_min = 0.9 * Load_pred;  % 负荷下界
Load_max = 1.1 * Load_pred;  % 负荷上界

1.2 变量定义（YALMIP）

matlab 复制代码

% -------------------------- 第一阶段变量（日前调度） --------------------------
x = sdpvar(4, T, 'full');  % 4类变量：[DG出力, 储能充电, 储能放电, 购电功率]
% x(1,:): DG出力 P_dg (kW)
% x(2,:): 储能充电 P_ess_cha (kW)
% x(3,:): 储能放电 P_ess_dis (kW)
% x(4,:): 购电功率 P_grid_buy (kW)，售电为负

SOC = sdpvar(1, T, 'full'); % 储能SOC (kWh)

% -------------------------- 第二阶段变量（实时调整） --------------------------
y = sdpvar(4, T, 'full');  % 调整变量：[DG调整量, 储能充电调整, 储能放电调整, 购电调整]
% y(1,:): ΔP_dg (kW)
% y(2,:): ΔP_ess_cha (kW)
% y(3,:): ΔP_ess_dis (kW)
% y(4,:): ΔP_grid_buy (kW)

% -------------------------- 不确定性变量 --------------------------
u = sdpvar(3, T, 'full');  % 不确定性变量：[光伏实际出力, 风机实际出力, 实际负荷]
% u(1,:): P_pv (kW)
% u(2,:): P_wind (kW)
% u(3,:): P_load (kW)

二、两阶段鲁棒优化模型构建

2.1 目标函数（总成本最小化）

matlab 复制代码

% 第一阶段成本：DG运行成本 + 储能损耗成本 + 购电成本
C_fix = 0;
for t = 1:T
    C_fix = C_fix + C_dg*x(1,t)*1 + ...  % DG成本 (元)
             0.05*abs(x(2,t) + x(3,t))*1 + ...  % 储能损耗（简化模型）
             C_grid_buy(t)*x(4,t)*1;  % 购电成本
end

% 第二阶段成本：调整成本（最坏场景下的额外成本）
C_adj = 0;
for t = 1:T
    C_adj = C_adj + C_dg*y(1,t)*1 + ...  % DG调整成本
             C_grid_buy(t)*y(4,t)*1;  % 购电调整成本
end

% 总目标函数
Objective = C_fix + max(u in U) min(y) C_adj;  % 两阶段鲁棒目标

2.2 约束条件

matlab 复制代码

Constraints = [];

% -------------------------- 第一阶段约束（日前调度） --------------------------
% 1. 储能SOC动态
SOC(1) = SOC0 + eta_cha*x(2,1) - x(3,1)/eta_dis;
for t = 2:T
    SOC(t) = SOC(t-1) + eta_cha*x(2,t) - x(3,t)/eta_dis;
end
Constraints = [Constraints, SOC_min*ESS_cap <= SOC <= SOC_max*ESS_cap];  % SOC上下限
Constraints = [Constraints, 0 <= x(2,:) <= ESS_power_max, 0 <= x(3,:) <= ESS_power_max];  % 储能充放电功率限制
Constraints = [Constraints, x(2,:).*x(3,:) == 0];  % 充放电互斥

% 2. DG出力限制
Constraints = [Constraints, 0 <= x(1,:) <= DG_cap];  % DG出力上下限

% 3. 功率平衡（预测场景）
P_renew_pred = PV_pred + Wind_pred;  % 预测可再生能源出力
for t = 1:T
    P_balance = x(1,t) + x(3,t) - x(2,t) + x(4,t) - (P_renew_pred(t) - Load_pred(t));  % 购电为正，售电为负
    Constraints = [Constraints, P_balance == 0];  % 功率平衡
end

% -------------------------- 第二阶段约束（实时调整） --------------------------
% 1. 不确定性集合（盒式集合）
for t = 1:T
    Constraints = [Constraints, 
        PV_min(t) <= u(1,t) <= PV_max(t), ...  % 光伏出力范围
        Wind_min(t) <= u(2,t) <= Wind_max(t), ...  % 风机出力范围
        Load_min(t) <= u(3,t) <= Load_max(t)];  % 负荷范围
end

% 2. 调整后功率平衡（实际场景）
P_renew_actual = u(1,:) + u(2,:);  % 实际可再生能源出力
for t = 1:T
    P_balance_adj = (x(1,t)+y(1,t)) + (x(3,t)+y(3,t)) - (x(2,t)+y(2,t)) + (x(4,t)+y(4,t)) - (P_renew_actual(t) - u(3,t));
    Constraints = [Constraints, P_balance_adj == 0];  % 调整后功率平衡
end

% 3. 调整变量限制
Constraints = [Constraints, -0.2*x(1,:) <= y(1,:) <= 0.2*x(1,:)];  % DG调整幅度±20%
Constraints = [Constraints, -ESS_power_max <= y(2,:) <= ESS_power_max, -ESS_power_max <= y(3,:) <= ESS_power_max];  % 储能调整限制
Constraints = [Constraints, y(2,:).*y(3,:) == 0];  % 充放电互斥

三、C&CG算法求解

3.1 算法初始化

matlab 复制代码

% 初始化C&CG算法参数
max_iter = 10;       % 最大迭代次数
tol = 1e-3;          % 收敛阈值
LB = -inf;           % 下界（主问题最优值）
UB = inf;           % 上界（子问题最优值）
iter = 0;            % 迭代次数

% 存储最坏场景和调整变量
u_scenarios = [];    % 最坏场景集合
y_scenarios = [];    % 对应调整变量集合

3.2 主问题求解（第一阶段决策）

matlab 复制代码

function [x_opt, SOC_opt, LB_new] = solve_master_problem(u_scenarios, y_scenarios, Constraints, Objective_part)
    % 构建主问题：min C_fix(x) + theta, s.t. theta >= C_adj(x, y^j, u^j)
    theta = sdpvar(1);  % 第二阶段成本估计值
    MP_objective = C_fix + theta;
    
    MP_constraints = Constraints;
    MP_constraints = [MP_constraints, theta >= C_adj];  % 对每个历史场景
    
    options = sdpsettings('solver', 'cplex', 'verbose', 0);
    sol = optimize(MP_constraints, MP_objective, options);
    
    if sol.problem == 0
        x_opt = value(x);
        SOC_opt = value(SOC);
        LB_new = value(MP_objective);
    else
        error('主问题求解失败');
    end
end

3.3 子问题求解（寻找最坏场景）

matlab 复制代码

function [u_opt, y_opt, UB_new] = solve_subproblem(x_opt, Constraints, Objective_adj)
    % 子问题：max_{u in U} min_y C_adj(x_opt, y, u)
    SP_objective = -C_adj;  % 转化为最小化负成本（等价于最大化成本）
    
    options = sdpsettings('solver', 'cplex', 'verbose', 0);
    sol = optimize([Constraints, SP_objective <= 0], SP_objective, options);  % 内层min_y
    
    if sol.problem == 0
        u_opt = value(u);
        y_opt = value(y);
        UB_new = value(C_fix) + value(C_adj);  % 更新上界
    else
        error('子问题求解失败');
    end
end

3.4 迭代求解主-子问题

matlab 复制代码

while iter < max_iter && (UB - LB) > tol
    iter = iter + 1;
    
    % 步骤1：求解主问题，得到第一阶段决策x_opt
    [x_opt, SOC_opt, LB_new] = solve_master_problem(u_scenarios, y_scenarios, Constraints, Objective);
    LB = LB_new;
    
    % 步骤2：求解子问题，寻找最坏场景u_opt和调整变量y_opt
    [u_opt, y_opt, UB_new] = solve_subproblem(x_opt, Constraints, C_adj);
    UB = min(UB, UB_new);  % 更新上界
    
    % 步骤3：存储最坏场景和调整变量
    u_scenarios = [u_scenarios; u_opt];
    y_scenarios = [y_scenarios; y_opt];
    
    % 打印迭代信息
    fprintf('迭代次数: %d, 下界: %.2f, 上界: %.2f, 间隙: %.2f%%\n', ...
        iter, LB, UB, 100*(UB-LB)/UB);
end

四、结果可视化与分析

4.1 绘制储能SOC变化曲线

matlab 复制代码

figure;
plot(1:T, value(SOC_opt), 'b-o', 'LineWidth', 1.5);
xlabel('时段 (h)'); ylabel('储能SOC (kWh)');
title('储能SOC动态变化');
grid on;
ylim([SOC_min*ESS_cap, SOC_max*ESS_cap]);

4.2 绘制设备出力对比

matlab 复制代码

figure;
subplot(3,1,1);
plot(1:T, value(x_opt(1,:)), 'r-o', 1:T, PV_pred, 'g--', 1:T, Wind_pred, 'b--');
legend('DG出力', '光伏预测', '风机预测');
ylabel('功率 (kW)'); title('电源出力对比'); grid on;

subplot(3,1,2);
plot(1:T, value(x_opt(2,:)), 'g-o', 1:T, value(x_opt(3,:)), 'r-o');
legend('储能充电', '储能放电'); ylabel('功率 (kW)'); grid on;

subplot(3,1,3);
plot(1:T, value(x_opt(4,:)), 'm-o');
ylabel('购电功率 (kW)'); xlabel('时段 (h)'); title('主网交互功率'); grid on;

4.3 总成本对比（鲁棒优化 vs 确定性优化）

matlab 复制代码

% 确定性优化模型（不考虑不确定性）
Objective_det = C_fix;  % 仅第一阶段成本
Constraints_det = Constraints;  % 去掉第二阶段约束
sol_det = optimize(Constraints_det, Objective_det, sdpsettings('solver', 'cplex'));
Cost_det = value(Objective_det);

% 鲁棒优化总成本
Cost_robust = value(Objective);

fprintf('确定性优化总成本: %.2f 元\n', Cost_det);
fprintf('鲁棒优化总成本: %.2f 元\n', Cost_robust);
fprintf('鲁棒性提升: %.2f%%\n', 100*(Cost_det - Cost_robust)/Cost_det);

参考代码微电网两阶段鲁棒优化经济调度方法 www.youwenfan.com/contentcss/160525.html

五、关键代码说明

变量定义 ：使用YALMIP的sdpvar定义第一阶段（x、SOC）和第二阶段（y）变量，以及不确定性变量（u）。
约束构建：包含储能SOC动态、功率平衡、设备出力限制、不确定性集合（盒式集合）等。
C&CG算法：通过迭代求解主问题（第一阶段决策）和子问题（最坏场景搜索），逐步逼近最优解。
结果可视化：绘制储能SOC、设备出力、总成本对比，直观展示优化效果。

六、扩展与优化方向

不确定性集合精细化：采用椭球集合或多面体集合替代盒式集合，减少保守性：

matlab 复制代码

% 椭球集合示例：||u - u_pred||_2 ≤ Γ (Γ为不确定预算)
Gamma = 5;  % 不确定预算
Constraints = [Constraints, norm(u - [PV_pred; Wind_pred; Load_pred], 2) <= Gamma];

多时间尺度耦合：结合日前调度（小时级）与实时调度（15分钟级），通过滚动优化提升适应性。
分布式求解：针对大规模微电网，采用ADMM算法分解协调各子网优化问题。