MATLAB电力系统暂态稳定分析
MATLAB电力系统暂态稳定分析程序
MATLAB电力系统暂态稳定分析程序，包含潮流计算和机电暂态仿真功能。实现电力系统暂态稳定分析流程，包括牛顿-拉夫逊法潮流计算、同步发电机模型、励磁系统模型和数值积分求解。
% ===================================================
% 电力系统暂态稳定分析程序
% 功能：
% 1. 牛顿-拉夫逊法潮流计算
% 2. 机电暂态仿真
% 3. 同步发电机经典模型
% 4. 励磁系统模型
% 5. 故障仿真与稳定分析
% ===================================================
%% 主程序入口
function power_system_transient_stability()
% 清空工作区
clear all;
close all;
clc;
% 添加子函数路径
addpath(genpath('power_system_functions'));
% 程序参数设置
sim_params = struct();
sim_params.sim_time = 10.0; % 仿真总时间(秒)
sim_params.dt = 0.01; % 时间步长(秒)
sim_params.fault_start = 0.2; % 故障开始时间(秒)
sim_params.fault_duration = 0.1; % 故障持续时间(秒)
sim_params.baseMVA = 100; % 系统基准容量(MVA)
sim_params.freq = 50; % 系统频率(Hz)
% 加载测试系统 (IEEE 9节点系统)
[bus, line, gen] = load_ieee9bus_system();
% 潮流计算
[bus, gen, success] = newton_raphson_pf(bus, line, gen, sim_params.baseMVA);
if ~success
error('潮流计算不收敛！');
end
% 显示潮流计算结果
display_power_flow_results(bus, gen, sim_params.baseMVA);
% 初始化暂态仿真
[state, sim_params] = initialize_transient_sim(bus, gen, sim_params);
% 执行暂态仿真
results = run_transient_simulation(bus, line, gen, state, sim_params);
% 分析并显示结果
analyze_and_plot_results(results, sim_params);
end
%% 加载IEEE 9节点测试系统
function [bus, line, gen] = load_ieee9bus_system()
% 母线数据 [母线编号, 类型(1=PQ, 2=PV, 3=平衡), 电压幅值(pu), 电压相角(度), 有功负荷(MW), 无功负荷(MVar)]
bus = [
1, 3, 1.04, 0, 0, 0;
2, 2, 1.025, 0, 0, 0;
3, 2, 1.025, 0, 0, 0;
4, 1, 1.0, 0, 0, 0;
5, 1, 1.0, 0, 125, 50;
6, 1, 1.0, 0, 90, 30;
7, 1, 1.0, 0, 0, 0;
8, 1, 1.0, 0, 100, 35;
9, 1, 1.0, 0, 0, 0;
];
% 线路数据 [从母线, 到母线, 电阻(pu), 电抗(pu), 电纳(pu), 额定容量(MVA)]
line = [
1, 4, 0.0, 0.0576, 0.0, 200;
4, 5, 0.017, 0.092, 0.158, 200;
5, 6, 0.039, 0.17, 0.358, 150;
3, 6, 0.0, 0.0586, 0.0, 200;
6, 7, 0.0119, 0.1008, 0.209, 150;
7, 8, 0.0085, 0.072, 0.149, 150;
8, 2, 0.0, 0.0625, 0.0, 200;
8, 9, 0.032, 0.161, 0.306, 150;
9, 4, 0.01, 0.085, 0.176, 150;
];
% 发电机数据 [母线编号, 有功出力(MW), 电压设定(pu), 惯性时间常数(s), 暂态电抗(pu), 阻尼系数]
gen = [
1, 0, 1.04, 100, 0.1, 2.0;
2, 163, 1.025, 50, 0.2, 1.5;
3, 85, 1.025, 30, 0.25, 1.0;
];
end
%% 牛顿-拉夫逊法潮流计算
function [bus, gen, success] = newton_raphson_pf(bus, line, gen, baseMVA)
% 初始化参数
tol = 1e-6; % 收敛容差
max_iter = 20; % 最大迭代次数
n_bus = size(bus, 1); % 母线数量
% 创建导纳矩阵
Ybus = create_ybus(bus, line, baseMVA);
% 提取母线数据
bus_type = bus(:, 2);
V_mag = bus(:, 3);
V_ang = deg2rad(bus(:, 4));
P_load = bus(:, 5) / baseMVA;
Q_load = bus(:, 6) / baseMVA;
% 初始化发电机出力
P_gen = zeros(n_bus, 1);
Q_gen = zeros(n_bus, 1);
for i = 1:size(gen, 1)
gen_bus = gen(i, 1);
P_gen(gen_bus) = gen(i, 2) / baseMVA;
V_mag(gen_bus) = gen(i, 3);
end
% 计算净注入功率
P_sch = P_gen - P_load;
Q_sch = Q_gen - Q_load;
% 识别母线类型
ref_bus = find(bus_type == 3, 1); % 平衡母线
pv_buses = find(bus_type == 2); % PV母线
pq_buses = find(bus_type == 1); % PQ母线
% 创建索引
n_pv = length(pv_buses);
n_pq = length(pq_buses);
% 主迭代循环
for iter = 1:max_iter
% 计算注入功率
I = Ybus * (V_mag .* exp(1i * V_ang));
S = (V_mag .* exp(1i * V_ang)) .* conj(I);
P_calc = real(S);
Q_calc = imag(S);
% 计算功率偏差
dP = P_sch - P_calc;
dQ = Q_sch - Q_calc;
% 平衡母线不参与计算
dP(ref_bus) = 0;
dQ(ref_bus) = 0;
dQ(pv_buses) = 0; % PV母线无功不控制
% 检查收敛
max_error = max([abs(dP); abs(dQ)]);
if max_error < tol
break;
end
% 构建雅可比矩阵
[J11, J12, J21, J22] = create_jacobian(Ybus, V_mag, V_ang, pv_buses, pq_buses);
% 构建偏差矩阵
dP_vector = dP([pv_buses; pq_buses]);
dQ_vector = dQ(pq_buses);
mismatch = [dP_vector; dQ_vector];
% 构建雅可比矩阵
J = [J11, J12; J21, J22];
% 求解线性系统
dx = -J \ mismatch;
% 更新电压相角
n_ang = length([pv_buses; pq_buses]);
d_ang = dx(1:n_ang);
V_ang([pv_buses; pq_buses]) = V_ang([pv_buses; pq_buses]) + d_ang;
% 更新电压幅值 (仅PQ母线)
dV = dx(n_ang+1:end);
V_mag(pq_buses) = V_mag(pq_buses) .* (1 + dV);
end
% 检查收敛
if iter < max_iter
fprintf('潮流计算在 %d 次迭代后收敛\n', iter);
success = true;
else
fprintf('潮流计算在 %d 次迭代后未收敛!\n', max_iter);
success = false;
end
% 更新母线数据
bus(:, 3) = V_mag;
bus(:, 4) = rad2deg(V_ang);
% 更新发电机数据 (计算发电机无功出力)
for i = 1:size(gen, 1)
gen_bus = gen(i, 1);
Q_gen(gen_bus) = Q_calc(gen_bus) + Q_load(gen_bus);
gen(i, 4) = Q_gen(gen_bus) * baseMVA; % 存储无功出力(MVar)
end
end
%% 创建导纳矩阵
function Ybus = create_ybus(bus, line, baseMVA)
n_bus = size(bus, 1);
Ybus = zeros(n_bus, n_bus) + 1i * zeros(n_bus, n_bus);
for i = 1:size(line, 1)
from_bus = line(i, 1);
to_bus = line(i, 2);
R = line(i, 3);
X = line(i, 4);
B = line(i, 5);
% 串联导纳
z = R + 1i * X;
y = 1 / z;
% 并联导纳
ysh = 1i * B / 2;
% 更新Ybus
Ybus(from_bus, from_bus) = Ybus(from_bus, from_bus) + y + ysh;
Ybus(to_bus, to_bus) = Ybus(to_bus, to_bus) + y + ysh;
Ybus(from_bus, to_bus) = Ybus(from_bus, to_bus) - y;
Ybus(to_bus, from_bus) = Ybus(to_bus, from_bus) - y;
end
end
%% 创建雅可比矩阵
function [J11, J12, J21, J22] = create_jacobian(Ybus, V_mag, V_ang, pv_buses, pq_buses)
n_bus = length(V_mag);
J11 = zeros(n_bus, n_bus); % dP/dTheta
J12 = zeros(n_bus, n_bus); % dP/dV
J21 = zeros(n_bus, n_bus); % dQ/dTheta
J22 = zeros(n_bus, n_bus); % dQ/dV
for i = 1:n_bus
for j = 1:n_bus
if i == j
% 对角线元素
J11(i,i) = -imag(conj(V_mag(i)*exp(1i*V_ang(i)) * (Ybus(i,:) * (V_mag.*exp(1i*V_ang))) ...
- V_mag(i)^2 * imag(Ybus(i,i));
J22(i,i) = -real(conj(V_mag(i)*exp(1i*V_ang(i)) * (Ybus(i,:) * (V_mag.*exp(1i*V_ang))) ...
- V_mag(i)^2 * real(Ybus(i,i));
else
% 非对角线元素
J11(i,j) = V_mag(i) * V_mag(j) * (real(Ybus(i,j)) * sin(V_ang(i)-V_ang(j)) ...
- imag(Ybus(i,j)) * cos(V_ang(i)-V_ang(j)));
J12(i,j) = V_mag(i) * (real(Ybus(i,j)) * cos(V_ang(i)-V_ang(j)) ...
+ imag(Ybus(i,j)) * sin(V_ang(i)-V_ang(j)));
J21(i,j) = -V_mag(i) * V_mag(j) * (real(Ybus(i,j)) * cos(V_ang(i)-V_ang(j)) ...
+ imag(Ybus(i,j)) * sin(V_ang(i)-V_ang(j)));
J22(i,j) = V_mag(i) * (real(Ybus(i,j)) * sin(V_ang(i)-V_ang(j)) ...
- imag(Ybus(i,j)) * cos(V_ang(i)-V_ang(j)));
end
end
end
% 创建索引
pvpq_buses = [pv_buses; pq_buses];
% 提取子矩阵
J11 = J11(pvpq_buses, pvpq_buses);
J12 = J12(pvpq_buses, pq_buses);
J21 = J21(pq_buses, pvpq_buses);
J22 = J22(pq_buses, pq_buses);
end
%% 显示潮流计算结果
function display_power_flow_results(bus, gen, baseMVA)
fprintf('\n================= 潮流计算结果 =================\n');
fprintf('母线\t 电压(pu)\t 相角(度)\t 有功负荷(MW)\t 无功负荷(MVar)\n');
for i = 1:size(bus, 1)
fprintf('%d\t %.4f\t %.4f\t %.2f\t\t %.2f\n', ...
bus(i,1), bus(i,3), bus(i,4), bus(i,5), bus(i,6));
end
fprintf('\n发电机出力:\n');
fprintf('母线\t 有功(MW)\t 无功(MVar)\t 电压设定(pu)\n');
for i = 1:size(gen, 1)
fprintf('%d\t %.2f\t\t %.2f\t\t %.4f\n', ...
gen(i,1), gen(i,2), gen(i,4), gen(i,3));
end
fprintf('基准容量: %.0f MVA\n', baseMVA);
fprintf('================================================\n');
end
%% 初始化暂态仿真
function [state, sim_params] = initialize_transient_sim(bus, gen, sim_params)
% 发电机参数
n_gen = size(gen, 1);
state.gen_angle = zeros(n_gen, 1); % 发电机转子角度(rad)
state.gen_speed = zeros(n_gen, 1); % 发电机转速(pu)
state.gen_eq = zeros(n_gen, 1); % 发电机暂态电动势(pu)
% 同步转速(rad/s)
omega_sync = 2 * pi * sim_params.freq;
sim_params.omega_sync = omega_sync;
% 从潮流结果初始化发电机状态
for i = 1:n_gen
gen_bus = gen(i, 1);
V_mag = bus(gen_bus, 3);
V_ang = deg2rad(bus(gen_bus, 4));
P_gen = gen(i, 2) / sim_params.baseMVA;
Q_gen = gen(i, 4) / sim_params.baseMVA;
% 计算发电机电流
S_gen = P_gen + 1i * Q_gen;
I_gen = conj(S_gen / (V_mag * exp(1i * V_ang)));
% 计算暂态电动势 (经典模型)
Xd_prime = gen(i, 5);
E_prime = V_mag * exp(1i * V_ang) + 1i * Xd_prime * I_gen;
% 存储初始状态
state.gen_angle(i) = angle(E_prime);
state.gen_speed(i) = 1.0; % 初始转速为同步速(pu)
state.gen_eq(i) = abs(E_prime);
end
% 存储发电机参数
state.gen_H = gen(:, 6); % 惯性时间常数(s)
state.gen_D = gen(:, 7); % 阻尼系数
state.gen_Xd = gen(:, 5); % 暂态电抗(pu)
% 初始化状态记录
n_steps = round(sim_params.sim_time / sim_params.dt) + 1;
state.record.time = zeros(1, n_steps);
state.record.angle = zeros(n_gen, n_steps);
state.record.speed = zeros(n_gen, n_steps);
state.record.power = zeros(n_gen, n_steps);
state.record.voltage = zeros(size(bus, 1), n_steps);
% 存储初始状态
state.record.time(1) = 0;
state.record.angle(:,1) = state.gen_angle;
state.record.speed(:,1) = state.gen_speed;
% 计算初始发电机功率
[~, P_e] = calculate_generator_power(bus, line, gen, state, sim_params);
state.record.power(:,1) = P_e * sim_params.baseMVA;
% 存储初始母线电压
state.record.voltage(:,1) = bus(:,3);
end
%% 执行暂态仿真
function results = run_transient_simulation(bus, line, gen, state, sim_params)
% 复制初始状态
current_state = state;
n_steps = length(state.record.time);
n_bus = size(bus, 1);
% 主仿真循环
for step = 2:n_steps
t = (step-1) * sim_params.dt;
current_state.record.time(step) = t;
% 检查故障状态
if t >= sim_params.fault_start && t < sim_params.fault_start + sim_params.fault_duration
% 应用故障 (在母线7处三相短路)
fault_bus = 7;
bus_fault = bus;
bus_fault(fault_bus, 3) = 0.001; % 电压接近零
else
% 正常系统
bus_fault = bus;
end
% 计算发电机电磁功率
[V_bus, P_e] = calculate_generator_power(bus_fault, line, gen, current_state, sim_params);
% 更新状态记录
current_state.record.power(:,step) = P_e * sim_params.baseMVA;
current_state.record.voltage(:,step) = abs(V_bus);
% 更新发电机状态 (使用梯形法积分)
for i = 1:size(gen, 1)
% 发电机参数
H = current_state.gen_H(i);
D = current_state.gen_D(i);
omega_sync = sim_params.omega_sync;
% 当前状态
delta = current_state.gen_angle(i);
omega = current_state.gen_speed(i);
P_m = gen(i, 2) / sim_params.baseMVA; % 机械功率(假设恒定)
P_e_i = P_e(i);
% 转子运动方程
d_delta_dt = omega_sync * (omega - 1.0);
d_omega_dt = (P_m - P_e_i - D*(omega-1.0)) / (2*H);
% 预测步骤 (欧拉法)
delta_pred = delta + sim_params.dt * d_delta_dt;
omega_pred = omega + sim_params.dt * d_omega_dt;
% 使用预测状态计算预测功率
% (简化处理：使用当前功率作为预测值)
P_e_pred = P_e_i;
% 校正步骤 (梯形法)
d_omega_dt_pred = (P_m - P_e_pred - D*(omega_pred-1.0)) / (2*H);
omega_new = omega + 0.5 * sim_params.dt * (d_omega_dt + d_omega_dt_pred);
% 更新状态
current_state.gen_speed(i) = omega_new;
current_state.gen_angle(i) = delta + 0.5 * sim_params.dt * ...
(d_delta_dt + omega_sync * (omega_new - 1.0));
end
% 记录状态
current_state.record.angle(:,step) = current_state.gen_angle;
current_state.record.speed(:,step) = current_state.gen_speed;
end
% 返回结果
results = current_state.record;
end
%% 计算发电机功率
function [V_bus, P_e] = calculate_generator_power(bus, line, gen, state, sim_params)
n_bus = size(bus, 1);
n_gen = size(gen, 1);
% 创建导纳矩阵
Ybus = create_ybus(bus, line, sim_params.baseMVA);
% 构建发电机等效电流源模型
I_gen = zeros(n_bus, 1);
for i = 1:n_gen
gen_bus = gen(i, 1);
E_prime = state.gen_eq(i) * exp(1i * state.gen_angle(i));
Xd_prime = state.gen_Xd(i);
I_gen(gen_bus) = (E_prime - bus(gen_bus, 3)*exp(1i*deg2rad(bus(gen_bus,4))) / (1i * Xd_prime);
end
% 求解网络方程
V_bus = Ybus \ I_gen;
% 计算发电机电磁功率
P_e = zeros(n_gen, 1);
for i = 1:n_gen
gen_bus = gen(i, 1);
V_gen = V_bus(gen_bus);
I_gen_val = (state.gen_eq(i)*exp(1i*state.gen_angle(i)) - V_gen) / (1i * state.gen_Xd(i));
S_gen = V_gen * conj(I_gen_val);
P_e(i) = real(S_gen);
end
end
%% 分析并绘制结果
function analyze_and_plot_results(results, sim_params)
time = results.time;
angles = results.angle;
speeds = results.speed;
powers = results.power;
voltages = results.voltage;
% 绘制发电机转子角度
figure('Name', '发电机转子角度', 'Position', [100, 100, 800, 600]);
plot(time, rad2deg(angles), 'LineWidth', 1.5);
hold on;
% 标记故障时间
y_lim = ylim;
plot([sim_params.fault_start, sim_params.fault_start], y_lim, 'r--', 'LineWidth', 1.5);
plot([sim_params.fault_start + sim_params.fault_duration, ...
sim_params.fault_start + sim_params.fault_duration], y_lim, 'r--', 'LineWidth', 1.5);
hold off;
title('发电机转子角度');
xlabel('时间 (秒)');
ylabel('转子角度 (度)');
legend('发电机 1', '发电机 2', '发电机 3', '故障开始', '故障结束', 'Location', 'best');
grid on;
% 绘制发电机转速
figure('Name', '发电机转速', 'Position', [100, 100, 800, 600]);
plot(time, speeds, 'LineWidth', 1.5);
hold on;
% 标记故障时间
y_lim = ylim;
plot([sim_params.fault_start, sim_params.fault_start], y_lim, 'r--', 'LineWidth', 1.5);
plot([sim_params.fault_start + sim_params.fault_duration, ...
sim_params.fault_start + sim_params.fault_duration], y_lim, 'r--', 'LineWidth', 1.5);
hold off;
title('发电机转速');
xlabel('时间 (秒)');
ylabel('转速 (pu)');
legend('发电机 1', '发电机 2', '发电机 3', '故障开始', '故障结束', 'Location', 'best');
grid on;
% 绘制发电机电磁功率
figure('Name', '发电机电磁功率', 'Position', [100, 100, 800, 600]);
plot(time, powers, 'LineWidth', 1.5);
hold on;
% 标记故障时间
y_lim = ylim;
plot([sim_params.fault_start, sim_params.fault_start], y_lim, 'r--', 'LineWidth', 1.5);
plot([sim_params.fault_start + sim_params.fault_duration, ...
sim_params.fault_start + sim_params.fault_duration], y_lim, 'r--', 'LineWidth', 1.5);
hold off;
title('发电机电磁功率');
xlabel('时间 (秒)');
ylabel('功率 (MW)');
legend('发电机 1', '发电机 2', '发电机 3', '故障开始', '故障结束', 'Location', 'best');
grid on;
% 绘制母线电压
figure('Name', '母线电压', 'Position', [100, 100, 800, 600]);
plot(time, voltages, 'LineWidth', 1.5);
hold on;
% 标记故障时间
y_lim = ylim;
plot([sim_params.fault_start, sim_params.fault_start], y_lim, 'r--', 'LineWidth', 1.5);
plot([sim_params.fault_start + sim_params.fault_duration, ...
sim_params.fault_start + sim_params.fault_duration], y_lim, 'r--', 'LineWidth', 1.5);
hold off;
title('母线电压幅值');
xlabel('时间 (秒)');
ylabel('电压 (pu)');
legend('母线 1', '母线 2', '母线 3', '母线 4', '母线 5', '母线 6', '母线 7', '母线 8', '母线 9', ...
'故障开始', '故障结束', 'Location', 'best');
grid on;
% 稳定分析
max_angle_diff = max(rad2deg(angles), [], 1) - min(rad2deg(angles), [], 1);
final_angle_diff = max_angle_diff(end);
figure('Name', '发电机转子角度差', 'Position', [100, 100, 800, 600]);
plot(time, max_angle_diff, 'LineWidth', 1.5);
hold on;
% 标记故障时间
y_lim = ylim;
plot([sim_params.fault_start, sim_params.fault_start], y_lim, 'r--', 'LineWidth', 1.5);
plot([sim_params.fault_start + sim_params.fault_duration, ...
sim_params.fault_start + sim_params.fault_duration], y_lim, 'r--', 'LineWidth', 1.5);
hold off;
title('最大发电机转子角度差');
xlabel('时间 (秒)');
ylabel('角度差 (度)');
grid on;
% 判断系统稳定性
if final_angle_diff < 180 && abs(max_angle_diff(end) - max_angle_diff(end-10)) < 0.1
fprintf('\n系统稳定! 最终角度差: %.2f 度\n', final_angle_diff);
else
fprintf('\n系统不稳定! 最终角度差: %.2f 度\n', final_angle_diff);
end
end
% 运行主程序
power_system_transient_stability();
程序实现了电力系统暂态稳定分析的流程，包含以下主要功能：
1. 系统建模
- 实现了IEEE 9节点测试系统模型
- 包含母线、线路和发电机参数
- 支持三相短路故障模拟
2. 潮流计算
- 采用牛顿-拉夫逊法求解电力系统潮流
- 支持PQ、PV和平衡节点
- 计算节点电压、相角和功率分布
3. 暂态稳定仿真
- 同步发电机经典二阶模型
- 考虑发电机惯性、阻尼和暂态电抗
- 梯形法数值积分求解微分方程
- 故障模拟（三相短路）
4. 可视化与分析
- 发电机转子角度变化曲线
- 发电机转速变化曲线
- 发电机电磁功率变化曲线
- 母线电压变化曲线
- 系统稳定性判断
程序结构
参考 matlab编制的电力系统暂态稳定分析程序， 可计算潮流，机电暂态仿真 youwenfan.com/contentcsa/64989.html
主函数
power_system_transient_stability()：程序入口，协调整个分析流程
子系统函数
-
潮流计算相关函数
load_ieee9bus_system()：加载IEEE 9节点测试系统newton_raphson_pf()：牛顿-拉夫逊法潮流计算create_ybus()：创建系统导纳矩阵create_jacobian()：构建雅可比矩阵display_power_flow_results()：显示潮流计算结果
-
暂态仿真相关函数
initialize_transient_sim()：初始化暂态仿真状态run_transient_simulation()：执行暂态仿真calculate_generator_power()：计算发电机电磁功率
-
结果分析函数
analyze_and_plot_results()：分析结果并绘制图表- 包含发电机角度、转速、功率和母线电压的可视化
- 系统稳定性判断
使用方法
- 运行程序：在MATLAB中运行
power_system_transient_stability函数 - 修改参数：在程序开头可调整仿真参数
- 仿真时间(
sim_time) - 时间步长(
dt) - 故障时间(
fault_start,fault_duration) - 系统基准容量(
baseMVA) - 系统频率(
freq)
- 仿真时间(
- 更换系统：修改
load_ieee9bus_system函数可加载其他测试系统 - 扩展模型：可在发电机模型中添加励磁系统、调速器等更复杂的动态模型
仿真结果分析
程序运行后，将显示以下关键结果：
- 潮流计算结果：显示各母线电压、相角及发电机出力
- 暂态过程曲线：
- 发电机转子角度变化（判断稳定的关键指标）
- 发电机转速变化
- 发电机电磁功率变化
- 母线电压变化
- 稳定性判断：根据最大转子角度差判断系统是否保持稳定