电力系统潮流计算课程设计牛顿拉夫逊法的应用课程设计.docx
《电力系统潮流计算课程设计牛顿拉夫逊法的应用课程设计.docx》由会员分享，可在线阅读，更多相关《电力系统潮流计算课程设计牛顿拉夫逊法的应用课程设计.docx（39页珍藏版）》请在冰豆网上搜索。
电力系统潮流计算课程设计牛顿拉夫逊法的应用课程设计
电力系统潮流计算课程设计
——牛顿-拉夫逊法的应用
学院:
电气工程学院
班级:
电125
学号:
1212002047
姓名:
王衡佳
教师:
张新松
日期:
2015.11.15
一、课程设计内容简介.........................1
1.课程设计课题...........................................1
2.电力系统潮流计算.......................................1
二、电力系统潮流计算方式.....................1
1.高斯-赛德尔迭代法.....................................1
2.牛顿-拉夫逊法..........................................1
3.P-Q分解法....................................................2
三、程序设计.................................3
1.程序设计环境...........................................3
2.主程序清单.............................................3
3.程序运行结果..........................................22
四、个人小结................................23
1.课程设计问答..........................................23
2.个人心得体会..........................................23
五、参考文献................................24
一、课程设计内容简介
1.课程设计课题
设计一个基于高斯赛德尔法或牛顿拉夫逊法的电力系统潮流计算程序，要求计算IEEE14节点，可采用VC++，MATLAB或其他工具实现，了解节点导纳矩阵内各元素的意义和PV节点与PQ节点的区别。
2.电力系统潮流计算
电力系统潮流计算是研究电力系统稳态运行运行情形的一种大体电气计算。
它的任务是按照给定的运行条件和网路结构肯定整个系统的运行状态，如各母线上的电压（幅值及相角）、网络中的功率散布和功率损耗等。
电力系统潮流计算的结果是电力系统稳固计算和故障分析的基础。
二、电力系统潮流计算方式
1.高斯-赛德尔迭代法
以导纳矩阵为基础，并应用高斯--塞德尔迭代的算法是在电力系统中最先取得应用的潮流计算方式，目前高斯一塞德尔法已很少利用。
将所求方程f（x）=0改写为x=ψ（x），不能直接得出方程的根，给一个猜想值x0得：
x1=ψ（x0）,又可取x1为猜想值，进一步得：
长处：
（1）原理简单，程序设计十分容易。
（2）导纳矩阵是一个对称且高度稀疏的矩阵，因此占用内存超级节省。
（3）就每次迭代所需的计算量而言，是各类潮流算法中最小的，而且和网络所包含的节点数成正比关系。
缺点：
（1）收敛速度很慢。
（2）对病态条件系统，计算往往会发生收敛困难：
如节点间相位角差专门大的重负荷系统、包括有负电抗支路（如某些三绕组变压器或线路串联电容等）的系统、具有较长的辐射形线路的系统、长线路与短线路接在同一节点上，而且长短线路的长度比值又专门大的系统。
（3）平衡节点所在位置的不同选择，也会影响到收敛性能。
2.牛顿-拉夫逊法
牛顿法是数学中求解非线性方程式的典型方式，有较好的收敛性。
自从20世纪60年代中期采用了最佳顺序消去法以后，牛顿法在收敛性、内存要求、计算速度方面都超过了其他方式，成为直到目前仍被普遍采用的方式。
长处：
（1）收敛速度快，若选择到一个较好的初值，算法将具有平方收敛特性，一般迭代4—5次即能够收敛到一个超级精准的解。
而且其迭代次数与所计算网络的规模大体无关。
（2）具有良好的收敛靠得住性，对于前面提到的对以节点导纳矩阵为基础的高斯一塞德尔法呈病态的系统，牛顿法均能靠得住地收敛。
（3）牛顿法所需的内存量及每次迭代所需时刻均较前述的高斯一塞德尔法为多，并与程序设计技能有紧密关系。
缺点：
牛顿法的靠得住收敛取决于有一个良好的启动初值。
若是初值选择不妥，算法有可能根本不收敛或收敛到一个无法运行的解点上。
解决方式：
对于正常运行的系统，各节点电压一般均在额定值周围，偏移不会太大，而且各节点间的相位角差也不大，所以对各节点能够采用统一的电压初值（也称为“平直电压”），“平直电压”法假定：
如此一般能取得满意的结果。
但如果系统因无功紧张或其它原因致使电压质量很差或有重载线路而节点间角差专门大时，仍用上述初始电压就有可能出现问题。
能够先用高斯一塞德尔法迭代1-2次；以此迭代结果作为牛顿法的初值，也能够先用直流法潮流求解一次以求得一个较好的角度初值，然后转入牛顿法迭代。
3.P-Q分解法
电力系统中常常利用的P-Q分解法派生于以极坐标表示的牛顿-拉夫逊法,其大体思想是把节点功率表示为电压向量的极坐标形式，以有功功率误差作为修正电压向量角度的依据，以无功功率误差作为修正电压幅值的依据，把有功和无功分开进行迭代其主要特点是以一个（n-1）阶和一个m阶不变的、对称的系数矩阵B,B代替原来的（n+m-1）阶转变的、不对称的系数矩阵M，以此提高计算速度，降低对运算机贮存容量的要求。
P-Q分解法在计算速度方面有显著的提高，迅速取得了推行。
本课程设计中不采用此方式，因此再也不过量赘述。
三、程序设计
1.程序设计环境
（1）采用方式:
牛顿-拉夫逊法
（2）设计工具：
VC++6.0程序
（3）运行环境：
win864位操作系统
2.主程序清单
#include
#include
#include
#include
#include
#include
#include
#include
constdoubleCalculateError=0.00001;//概念计算收敛条件
staticintAllNodeNumber;//节点总数
staticintBranchNumber;//支路总数
staticintGroundNumber;//接地支路总数
classBUS
{
public:
intOldNumber;//旧的节点编号
intNodeType;//节点类型（0－pq节点,2－pv节点,3－平衡节点）
doubleLoadP;//负荷有功
doubleLoadQ;//负荷无功
doubleGenP;//发电机有功
doubleGenQ;//发电机无功
doubleVoltageVal;//电压幅值
doubleVoltageAngle;//电压相角
doubleNodeP;//节点净有功
doubleNodeQ;//节点净无功
doubleNodeE;//电压e分量
doubleNodeF;//电压f分量
BUS（）:
OldNumber（0）,NodeType（0）,LoadP（0）,LoadQ（0）,GenP（0）,GenQ（0）,VoltageVal（1.0）,VoltageAngle（0.0）,NodeP（0.0）,NodeQ（0.0）,NodeE（1.0）,NodeF（0.0）{
}
};
classBRANCH
{
public:
intNodeI;//节点i侧
intNodeJ;//节点j侧
intCircuit;//判断是不是是双回路（0单回路，1双回路）
doubleR;//支路电阻
doubleX;//支路电抗
doubleY;//线路变压器变比或接地导纳B
BRANCH（）:
NodeI（0）,NodeJ（0）,Circuit
（1）,R（0.0）,X（0.0）,Y（0.0）{
}
};
classYii//存导纳矩阵对角元素
{
public:
doubleG,B;
Yii（）:
G（0.0）,B（0.0）{}
};
classYij//存导纳矩阵非对角元素和列号
{
public:
doubleG,B;
intj;
Yij（）:
G（0）,B（0）,j（0）{
}
};
classGROUND//存接地支路数据
{
public:
intNode;
doubleG;
doubleB;
};
classCURRENT//存支路电流
{
public:
doubleE,F;
};
classPOWER//存支路功率
{
public:
doubleP1,Q1;
doubleP2,Q2;
};
classPOWERFLOW
{
public:
doublemaxerror;
char*FileName,*ResultName;
voidInputData（）;//读入系统数据
voidTinny2（）;//半动态节点优化编号
voidFormY（）;//形成节点导纳矩阵
voidFormJ（）;//形成雅克比矩阵（边形成边消去）
voidbranchpower（）;//计算支路功率
voidoutputdata（）;//输出潮流计算结果
ifstreaminput;
ofstreamoutput;
POWERFLOW（）;
~POWERFLOW（）;
private:
int*NewNumber;//按新号顺序存旧号
int*OldNewNumber;//按旧号顺序存新号
BUS*bus;
BRANCH*branch;
GROUND*ground;
CURRENT*I;//迭代后计算的各支路的电流
POWER*power;//各支路功率
doubleBaseS;
Yii*yii;
Yij*yij;
int*seq;//导纳矩阵各行非对角元素首地址
int*sum;//导纳矩阵各行非对角元素个数
double*a;//电流分量
double*b;//电流分量
double*groundpower;//接地支路功率
intcount;//记录迭代次数
};
POWERFLOW:
:
POWERFLOW（）
{
FileName=NULL;
ResultName=NULL;
NewNumber=NULL;
bus=NULL;
branch=NULL;
ground=NULL;
BaseS=0;
count=0;
}
POWERFLOW:
:
~POWERFLOW（）
{
delete[]NewNumber;
delete[]OldNewNumber;
delete[]bus;
delete[]branch;
delete[]I;
delete[]power;
delete[]yii;
delete[]yij;
delete[]seq;
delete[]sum;
delete[]a;
delete[]b;
}
voidPOWERFLOW:
:
InputData（）//读入数据
{
input.open（FileName,ios:
:
nocreate）;
input>>BaseS;
if（!
input）
{
cout<<"数据文件有问题!
请检查!
"<return;
}
input>>AllNodeNumber;
bus=newBUS[AllNodeNumber];
for（inti=0;i{
input>>bus[i].OldNumber>>bus[i].NodeType>>bus[i].LoadP>>bus[i].LoadQ
>>bus[i].GenP>>bus[i].GenQ>>bus[i].VoltageAngle>>bus[i].VoltageVal;
bus[i].NodeE=bus[i].VoltageVal*cos（bus[i].VoltageAngle*3.14159265/180）;
bus[i].NodeF=bus[i].VoltageVal*sin（bus[i].VoltageAngle*3.14159265/180）;
bus[i].NodeP=（bus[i].GenP-bus[i].LoadP）/BaseS;
bus[i].NodeQ=（bus[i].GenQ-bus[i].LoadQ）/BaseS;
}
input>>BranchNumber;
branch=newBRANCH[BranchNumber];
for（i=0;i{
input>>branch[i].NodeI>>branch[i].NodeJ>>branch[i].R>>branch[i].X>>branch[i].Y;
if（i==1）
branch[i].Circuit=0;
else
if（（branch[i].NodeI==branch[i-1].NodeI）&&（branch[i].NodeJ==branch[i-1].NodeJ））
{
branch[i].Circuit=1;
branch[i-1].Circuit=1;
}
elsebranch[i].Circuit=0;
}
input>>GroundNumber;
ground=newGROUND[GroundNumber];
for（i=0;i{
input>>ground[i].Node>>ground[i].G>>ground[i].B;
}
input.close（）;
}
voidPOWERFLOW:
:
Tinny2（）//半动态节点优化编号
{
NewNumber=newint[AllNodeNumber+1];
int*ConnectNum=newint[AllNodeNumber+1];
int**NodeConnect=newint*[AllNodeNumber+1];
for（inti=0;i<（AllNodeNumber+1）;i++）
NodeConnect[i]=newint[15];
for（i=1;i<（AllNodeNumber+1）;i++）
{
ConnectNum[i]=0;
}
for（i=0;i{
ConnectNum[abs（branch[i].NodeI）]++;
ConnectNum[abs（branch[i].NodeJ）]++;
NodeConnect[abs（branch[i].NodeI）][ConnectNum[abs（branch[i].NodeI）]]=abs（branch[i].NodeJ）;
NodeConnect[abs（branch[i].NodeJ）][ConnectNum[abs（branch[i].NodeJ）]]=abs（branch[i].NodeI）;
if（branch[i].Circuit==1）
++i;
}
for（intz=1;z<（AllNodeNumber+1）;z++）
{
NewNumber[z]=1;
for（i=1;i<（AllNodeNumber+1）;i++）
{
if（ConnectNum[NewNumber[z]]>ConnectNum[i]）
NewNumber[z]=i;
}
if（ConnectNum[NewNumber[z]]==1）
{
for（intj=1;j<（ConnectNum[NodeConnect[NewNumber[z]][1]]+1）;j++）
{
if（NodeConnect[NodeConnect[NewNumber[z]][1]][j]==NewNumber[z]）
{
NodeConnect[NodeConnect[NewNumber[z]][1]][j]=NodeConnect[NodeConnect[NewNumber[z]][1]][ConnectNum[NodeConnect[NewNumber[z]][1]]];
}
}
ConnectNum[NodeConnect[NewNumber[z]][1]]--;
}
else
{
for（i=1;i<（ConnectNum[NewNumber[z]]+1）;i++）
{
for（intj=1;j<（ConnectNum[NodeConnect[NewNumber[z]][i]]+1）;j++）
{
if（NodeConnect[NodeConnect[NewNumber[z]][i]][j]==NewNumber[z]）
NodeConnect[NodeConnect[NewNumber[z]][i]][j]=NodeConnect[NodeConnect[NewNumber[z]][i]][ConnectNum[NodeConnect[NewNumber[z]][i]]];
}
ConnectNum[NodeConnect[NewNumber[z]][i]]--;
}
for（i=1;i<（ConnectNum[NewNumber[z]]）;i++）
{
for（intk=i+1;k<（ConnectNum[NewNumber[z]]+1）;k++）
{
for（intj=1;j<（ConnectNum[NodeConnect[NewNumber[z]][i]]+1）;j++）
{
if（NodeConnect[NewNumber[z]][k]!
=NodeConnect[NodeConnect[NewNumber[z]][i]][j]）
continue;
elsebreak;
}
if（j==（ConnectNum[NodeConnect[NewNumber[z]][i]]+1））
{
ConnectNum[NodeConnect[NewNumber[z]][i]]++;
ConnectNum[NodeConnect[NewNumber[z]][k]]++;
NodeConnect[NodeConnect[NewNumber[z]][i]][ConnectNum[NodeConnect[NewNumber[z]][i]]]=NodeConnect[NewNumber[z]][k];
NodeConnect[NodeConnect[NewNumber[z]][k]][ConnectNum[NodeConnect[NewNumber[z]][k]]]=NodeConnect[NewNumber[z]][i];
}
}
}
}
ConnectNum[NewNumber[z]]=AllNodeNumber;
}
for（i=1;i<（AllNodeNumber+1）;i++）//新号数组中对应的老号
cout<cout<OldNewNumber=newint[AllNodeNumber+1];
for（i=1;i<（AllNodeNumber+1）;i++）
{
for（intj=1;j<（AllNodeNumber+1）;j++）
{
if（NewNumber[j]==i）
OldNewNumber[i]=j;
}
}
for（i=1;i<（AllNodeNumber+1）;i++）//老号数组中对应的新号
cout<cout<delete[]ConnectNum;
for（i=0;i<（AllNodeNumber+1）;i++）
delete[15]NodeConnect[i];
}
voidPOWERFLOW:
:
FormY（）//形成导纳矩阵
{
intz=1;
yii=newYii[AllNodeNumber+1];
yij=newYij[BranchNumber+1];
seq=newint[AllNodeNumber+1];
sum=newint[AllNodeNumber];
for（intf=0;f{
seq[f]=0;
sum[f]=0;
}
seq[AllNodeNumber]=0;
for（inti=1;i{
for（intj=0;j{
if（（NewNumber[i]==abs（branch[j].NodeI））||（NewNumber[i]==abs（branch[j].NodeJ）））
{
if（OldNewNumber[abs（branch[j].NodeI）]continue;
doubleZ=branch[j].R*branch[j].R+branch[j].X*branch[j].X;
if（branch[j].NodeI<0）
{
if（branch[j].Circuit==1）
{
doubleZ1=branch[j+1].R*branch[j+1].R+branch[j+1].X*branch[j+1].X;
yij[z].G=-branch[j].R/（Z*branch[j].Y）-branch[j+1].R/（Z1*branch[j+1].Y）;
yij[z].B=branch[j].X/（Z*bran
升级会员 