自动控制装置课程设计电力系统潮流计算的程序设计.docx
《自动控制装置课程设计电力系统潮流计算的程序设计.docx》由会员分享，可在线阅读，更多相关《自动控制装置课程设计电力系统潮流计算的程序设计.docx（32页珍藏版）》请在冰豆网上搜索。
自动控制装置课程设计电力系统潮流计算的程序设计
《自动控制装置语言程序设计》
题目:
电力系统潮流计算的程序设计
系别:
自动化学院
专业:
07电气工程及其自动化
（低压电力智能控制方向）
前言
潮流计算是研究电力系统稳态运行情况的一种基本电气计算，常规潮流计算的任务是根据给定的运行条件和网路结构确定整个系统的运行状态，如各母线上的电压（幅值及相角）、网络中的功率分布以及功率损耗等。
潮流计算的结果是电力系统稳定计算和故障分析的基础。
具体表现在以下方面：
（1）在电网规划阶段,通过潮流计算,合理规划电源容量及接入点,合理规划网架,选择无功补偿方案,满足规划水平的大、小方式下潮流交换控制、调峰、调相、调压的要求。
（2）在编制年运行方式时,在预计负荷增长及新设备投运基础上,选择典型方式进行潮流计算,发现电网中薄弱环节,供调度员日常调度控制参考,并对规划、基建部门提出改进网架结构,加快基建进度的建议。
（3）正常检修及特殊运行方式下的潮流计算,用于日运行方式的编制,指导发电厂开机方式,有功、无功调整方案及负荷调整方案,满足线路、变压器热稳定要求及电压质量要求。
（4）预想事故、设备退出运行对静态安全的影响分析及作出预想的运行方式调整方案。
总结为在电力系统运行方式和规划方案的研究中，都需要进行潮流计算以比较运行方式或规划供电方案的可行性、可靠性和经济性。
同时，为了实时监控电力系统的运行状态，也需要进行大量而快速的潮流计算。
因此，潮流计算是电力系统中应用最广泛、最基本和最重要的一种电气运算。
在系统规划设计和安排系统的运行方式时，采用离线潮流计算；在电力系统运行状态的实时监控中，则采用在线潮流计算。
随着计算机技术的迅速发展和普及，电子计算机已成为分析计算复杂电力系统各种运行情况的主要工具。
目录
目录1
一、课程设计目的和任务2
二、设计主要仪器设备和材料3
三、牛顿法潮流计算的步骤及计算程序框图4
四、程序代码7
五、计算结果24
六、小结与展望24
七、致谢25
八、主要参考文献25
一、课程设计目的和任务
设计目的：
通过对电力系统分析的学习，了解电力系统的运行和能量管理，计算电力系统潮流分布以及有功和无功功率的分点，掌握电力系统环网（牛顿-拉夫逊法、P-Q分解法）的计算方法。
并熟练使用计算机编程。
设计任务：
如图所示电力系统节点潮流及阻抗、导纳分布图，用直角坐标牛顿拉夫逊法（极坐标牛顿-拉夫逊法、P-Q分解法）计算机编程计算各线路潮流分布。
写出编程思想及流程框图。
并附录原程序。
图1IEEE9节点电力系统线路图
IEEE9节点电力系统原始数据：
图中GEN1节点为平衡节点，V1=1.04，GEN2和GEN3为PV节点，V2=1.025，P2=1.63，V3=1.025，P3=0.85，其他节点为PQ节点，S7=1.25+j0.5，S8=0.9+j0.3，S9=1.0+j0.35。
表1系统基本参数数据
节点总数
基准电压（KV）
基准功率（MW）
平衡节点
PV节点
PQ节点
计算精度
9
345
100
GEN1
GEN2,3
4~9
10（-1~-14）
表2系统线路原始参数（标幺值）
标号
起始节点i
终止节点j
电阻（R）
电抗（jX）
对地导纳（B/2）
1
2
5
0.000
0.063
0.000
2
5
9
0.019
0.072
0.075
3
6
9
0.012
0.101
0.105
4
3
6
0.000
0.059
0.000
5
6
8
0.039
0.170
0.179
6
4
8
0.017
0.092
0.079
7
5
7
0.032
0.161
0.153
8
4
7
0.010
0.085
0.088
9
1
4
0.000
0.058
0.000
表3节点功率、电压数据（标幺值）
标号
节点I
P
Q
V
1
1
1.000
1.000
1.040
2
2
1.630
1.000
1.025
3
3
0.850
1.000
1.025
4
4
0.000
0.000
1.000
5
5
0.000
0.000
1.000
6
6
0.000
0.000
1.000
7
7
-1.250
-0.500
1.000
8
8
-0.900
-0.300
1.000
9
9
-1.000
-0.350
1.000
二、设计主要仪器设备和材料
表4设计主要设备
序号
名称
主要用途
计算机
程序编写
三、牛顿法潮流计算的步骤及计算程序框图
牛顿法潮流计算的求解过程大致可以分为以下几步：
（1）输入系统的原始数据，包括系统的信息，各线路和变压器所在节点的编号和等值电路中的参数；各负荷所在节点的编号及其所取用的有功功率和无功功率；作为PQ节点的发电机所在节点和编号及所给定的有功功率和无功功率，PV节点的编号和所接发电机的有功功率和电压有效值的给定值，平衡节点的编号和给定的电压有效值。
（2）形成节点导纳矩阵。
（3）给定各PQ节点的电压初值和除平衡节点外各节点电压相位的初值
并组成待求量的初始向量
和
。
（4）置迭代次数k=0。
（5）应用
、
及PV节点和平衡节点所给定的电压，按式1：
计算各PQ节点的有功功率误差
和无功功率误差
以及各PV节点的有功功率误差
，并组成功率误差向量
和
。
（6）按式2：
中的收敛判据判断最大的功率误差是否小于容许值，如果满足则转到第（11）步，否则进行下一步。
（7）应用
、
按式3和式4：
计算雅可比矩阵元素，并形成式5中的雅可比矩阵
。
（8）解修正方程式5，得出
和
。
（9）应用式6：
计算各节点电压和相位的修正值，即新的初值。
（10）置k=k+1返回第（5）步继续进行下一轮迭代。
（11）按式7：
计算平衡节点的发电机（或注入）有功功率和无功功率，并按式8：
计算各PV节点发电机（或注入）的无功功率；按式9和式10：
计算各元件两端的功率和损耗，最后输出计算结果。
与上述步骤相对应的计算程序框图如下图所示：
四、程序代码
//文件一，NEquation.h:
interfacefortheNEquationclass.//
//////////////////////////////////////////////////////////////////////
#if!
defined（AFX_NEQUATION_H__7D6DCBC7_B370_4F2E_A720_4FB8BA7B55D9__INCLUDED_）
#defineAFX_NEQUATION_H__7D6DCBC7_B370_4F2E_A720_4FB8BA7B55D9__INCLUDED_
#if_MSC_VER>1000
#pragmaonce
#endif//_MSC_VER>1000
#defineCHECKERROR
classNEquation
{
public:
NEquation（）;
virtual~NEquation（）;
public:
voidSetSize（intsize）;
double&Data（intlhs,intrhs）;
double&Value（intlhs）;
intRun（）;
protected:
intm_nNumber;
double*m_nDataBuffer;
double*m_nValue;
voidFactorial（）;
voidForward（）;
voidBackward（）;
virtualdoubleZEROD（）;
virtualdoubleZEROV（）;
};
NEquation:
:
NEquation（）
{
m_nDataBuffer=NULL;
m_nValue=NULL;
m_nNumber=0;
}
NEquation:
:
~NEquation（）
{
if（m_nDataBuffer!
=NULL）delete[]m_nDataBuffer;
if（m_nValue!
=NULL）delete[]m_nValue;
}
doubleNEquation:
:
ZEROD（）{return0.0;}
doubleNEquation:
:
ZEROV（）{return0.0;}
voidNEquation:
:
SetSize（intsize）
{
if（size<1）return;
if（m_nDataBuffer!
=NULL）delete[]m_nDataBuffer;
if（m_nValue!
=NULL）delete[]m_nValue;
m_nDataBuffer=newdouble[size*size];
m_nValue=newdouble[size];
for（inti=0;ifor（i=0;im_nNumber=size;
}
double&NEquation:
:
Data（intlhs,intrhs）
{
#ifdefined（CHECKERROR）
if（（lhs=0）&&（rhs=0））
#endif
returnm_nDataBuffer[lhs*m_nNumber+rhs];
#ifdefined（CHECKERROR）
else
printf（"Error"）;
returnm_nDataBuffer[0];
#endif
}
double&NEquation:
:
Value（intlhs）
{
#ifdefined（CHECKERROR）
if（（lhs=0））
#endif
returnm_nValue[lhs];
#ifdefined（CHECKERROR）
else
printf（"Error"）;
returnm_nValue[0];
#endif
}
intNEquation:
:
Run（）
{
Factorial（）;
Forward（）;
Backward（）;
return1;
}
doublereverse（doubleff）{return（double）1.0/ff;};
voidNEquation:
:
Factorial（）
{
inti,j,k;
for（i=0;i{
//规格化formatline;
Data（i,i）=reverse（Data（i,i））;
for（j=i+1;j//消去
for（j=i+1;j{
for（k=i+1;k{
Data（j,k）=Data（j,k）-Data（j,i）*Data（i,k）;
}
}
}
}
voidNEquation:
:
Forward（）
{
inti,j;
for（i=0;i{
Value（i）=Data（i,i）*Value（i）;
for（j=i+1;jValue（j）=Value（j）-Data（j,i）*Value（i）;
}
}
voidNEquation:
:
Backward（）
{
inti,j;
for（i=1;i{
for（j=1;jValue（m_nNumber-i-1）-=Data（m_nNumber-i-1,m_nNumber-j）*Value（m_nNumber-j）;
}
}
#endif//!
defined（AFX_NEQUATION_H__7D6DCBC7_B370_4F2E_A720_4FB8BA7B55D9__INCLUDED_）
//////////文件二，LF.h//////////////
#ifndef_LF_LCR_
#define_LF_LCR_
#include"DataDesign.h"
intMakeY（intnB,intnL,Line*sL,double**YG,double**YB）;
intCalDeltaPQ（intnpv,intnpq,Bus*bus,double**YG,double**YB,int*p_Jtobus,double*deltaf）;
intFormJacobian（intnpv,intnpq,Bus*bus,double**YG,double**YB,int*p_Jtobus,double**Jac）;
#endif//_LF_LCR_
////////文件三，数据设计，DataDesign.h//////////
#ifndef_DATA_LCR_INCLUDE_
#define_DATA_LCR_INCLUDE_
structLine
{
intNum,NumI,NumJ,Type;
doubleR,X,B,K;
};
structBus
{
intNum;
doubleVolt,Phase,GenP,GenQ,LoadP,LoadQ;
intType;
};
structShunt
{
intNum,NumI;
doubleG,B;
};
#endif//_DATA_LCR_INCLUDE_
/////文件四，FormF.cpp//////////
#include
#include
#include"LF.h"
#include"DataDesign.h"
#include
//formdeltapanddeltaq
intCalDeltaPQ（intnpv,intnpq,Bus*bus,double**YG,double**YB,int*p_Jtobus,double*deltaf）
{
inti,j;//循环变量
intk;//节点修正变量
doublei1,i2;
doubledphase;
for（i=0;i{
if（i{
i1=0;
k=p_Jtobus[i];
for（j=0;j{
dphase=bus[k].Phase-bus[j].Phase;
i1+=bus[j].Volt*（YG[k][j]*cos（dphase）+YB[k][j]*sin（dphase））;
}
deltaf[i]=bus[k].GenP-bus[k].LoadP-bus[k].Volt*i1;
}
else
{//formdeltaQ
i2=0;
k=p_Jtobus[i];
for（j=0;j{
dphase=bus[k].Phase-bus[j].Phase;
i2+=bus[j].Volt*（YG[k][j]*sin（dphase）-YB[k][j]*cos（dphase））;
}
deltaf[i]=bus[k].GenQ-bus[k].LoadQ-bus[k].Volt*i2;
}
}
for（i=0;ideltaf[i]*=（-1）;
return1;
}
/////文件五，计算雅可比矩阵，FormJ.cpp///////////
#include
#include
#include"LF.h"
#include"DataDesign.h"
#include
#include
//////////////生成雅可比矩阵///////////////////
intFormJacobian（intnpv,intnpq,Bus*bus,double**YG,double**YB,int*p_Jtobus,double**Jac）
{
inti,j;
intnp=npv+npq;
doubledphase;
////////生成H矩阵////////////
double**H;
H=（double**）newchar[（np）*sizeof（void*）];
for（i=0;i{
H[i]=newdouble[np];
memset（H[i],0,sizeof（double）*（np））;//清零
}
for（i=0;i{
doubletemp=0;
for（j=0;j{
if（i!
=j）
{
dphase=bus[i+1].Phase-bus[j+1].Phase;
H[i][j]=bus[i+1].Volt*bus[j+1].Volt*（YG[i+1][j+1]*sin（dphase）-YB[i+1][j+1]*cos（dphase））;
temp+=H[i][j];
}
}
doubledphase1=bus[i].Phase-bus[0].Phase;
H[i][i]=temp*（-1）-bus[i+1].Volt*bus[0].Volt*（YG[i+1][0]*sin（dphase1）-YB[i+1][0]*cos（dphase））;
}
ofstreamfout1（"out.txt",ios:
:
app）;
/////////生成L矩阵////////////
double**L;
L=（double**）newchar[（np）*sizeof（void*）];
for（i=0;i{
L[i]=newdouble[np];
memset（L[i],0,sizeof（double）*（np））;
}
for（i=npv;i{
for（j=npv;j{
if（i!
=j）
{
L[i][j]=H[i][j];
}
}
L[i][i]=-1*H[i][i]-2*bus[i+1].Volt*bus[i+1].Volt*YB[i+1][i+1];
}
/////////////生成J矩阵///////////////////
double**J;
J=（double**）newchar[（np）*sizeof（void*）];
for（i=0;i{
J[i]=newdouble[np];
memset（J[i],0,sizeof（double）*（np））;
}
for（i=npv;i{
doubletemp=0;
for（j=0;j{
if（i!
=j）
{
dphase=bus[i+1].Phase-bus[j+1].Phase;
J[i][j]=-1*bus[i+1].Volt*bus[j+1].Volt*（YG[i+1][j+1]*cos（dphase）+YB[i+1][j+1]*sin（dphase））;
temp+=-1*J[i][j];
}
}
J[i][i]=temp;
}
/////////////////生成N矩阵/////////////////
double**N;
N=（double**）newchar[（np）*sizeof（void*）];
for（i=0;i{
N[i]=newdouble[np];
memset（N[i],0,sizeof（double）*（np））;
}
for（i=0;i{
for（j=npv;j{
if（i!
=j）
{
N[i][j]=-1*J[i][j];
}
}
N[i][i]=J[i][i]+2*bus[i+1].Volt*bus[i+1].Volt*YG[i+1][i+1];
}
for（i=0;ifor（j=0;jJac[i][j]=H[i][j];
for（i=np;ifor（j=0;jJac[i][j]=J[i-np+2][j];
for（i=0;ifor（j=np;jJac[i][j]=N[i][j-np+2];
for（i=np;ifor（j=np;jJac[i][j]=L[i-np+2][j-np+2];
//////////////////输出雅可比矩阵///////////////////////
ofstreamfout（"out.txt",ios:
:
app）;
static
升级会员 