华电潮流上机课程设计报告+程序.docx
《华电潮流上机课程设计报告+程序.docx》由会员分享，可在线阅读，更多相关《华电潮流上机课程设计报告+程序.docx（28页珍藏版）》请在冰豆网上搜索。
华电潮流上机课程设计报告+程序
《电力系统潮流上机》课程设计报告
院系：
电气与电子工程学院
班级：
学号：
学生姓名：
*******
设计周数：
成绩：
日期：
2012年1月5日
一、课程设计的目的与要求
培养学生的电力系统潮流计算机编程能力，掌握计算机潮流计算的相关知识
二、设计正文（详细内容见附录）
1．手算
2．计算机计算
3．思考题
3.1潮流计算的方法有哪些？
各有何特点？
答：
潮流计算的方法主要有高斯-赛德尔迭代法、牛顿-拉夫逊迭代法和P-Q分解法。
它们各自的特点如下：
（1）高斯-赛德尔迭代法分为以节点导纳矩阵为基础的高斯-赛德尔迭代法和以以节点阻抗矩阵为基础的高斯-赛德尔迭代法的原理比较简单，要求的数字计算机的内存量也比较小，但收敛性差，当系统规模变大时，迭代次数急剧上升，往往出现迭代不收敛的情况；而阻抗法改善了电力系统潮流计算导纳法德收敛性问题，在当时获得了广泛的应用，但是，阻抗法的主要缺点是占用计算机的内存很大，每次迭代的计算量很大。
当系统不断扩大时，这些缺点就更加突出。
（2）牛顿-拉夫逊法是数学中求解非线性方程式的典型方法，有较好的收敛性。
只要在迭代过程中尽可能保持方程式系数矩阵的稀疏性，就可以大大提高牛顿潮流计算程序的计算效率，牛顿法在收敛性、内存要求、计算速度方面都超过了阻抗法，成为知道目前仍被广泛采用的方法。
（3）P-Q分解法潮流计算派生于以极坐标表示时的牛顿-拉夫逊法，它根据电力系统的特点，抓住主要矛盾，对纯数学的牛顿法进行了改造。
与牛顿法相比，P-Q分解法的修正方程的系数矩阵B’和B”分别是（n-1）和（m-1）的方阵，替代了原有的（n+m-2）阶系数矩阵J；B’、B”在迭代过程中可以保持不变且为对称的系数矩阵，提高了计算速度，降低了对存储容量的要求。
P-Q分解法在计算速度方面有显著地提高，迅速得到了推广。
3.2如果交给你一个任务，请你用已有的潮流计算软件计算北京城市电网的潮流，你应该做哪些工作？
（收集哪些数据，如何整理，计算结果如何分析）
答：
（1）在进行北京城市电网的潮流计算之前需要了解北京城市电网中所有的节点支路的相关数据，并对节点和支路分类。
处理PQ节点时要了解节点的注入有功和无功功率；PV节点要了解节点电压大小，注入有功功率及节点所能提供的最大和最小无功功率；对于平衡节点要了解节点的电压大小、相位及节点所能提供的最大和最小有功无功功率，此外还需的节点数据有：
支路的电阻电抗电纳支路变压器的变比及线路所能传输的最大容量等。
（3）计算结果分析：
应考虑PQ节点的电压是否过高或过低，分析PV节点的电压幅值是否正常及无功功率是否超出范围，分析平衡节点有功无功功率是否在节点所能提供的范围之内，分析各支路的功率，看是否超出线路传输的最大容量，分析整个系统的网损是否达到标准
3.3设计中遇到的问题和解决的办法。
开始时我们进行原始数据的读入和读出，这一部分的程序比较简单，所以我们都很顺利都写出程序。
接下来就是节点导纳矩阵的形成。
编写这一部分程序时我刚开始没有考虑到变压器支路，所以当原始数据改为四节点四支路的数据时，节点导纳矩阵的结果就出错了。
经过改正之后终于得出了正确的节点导纳矩阵。
然后就是计算不平衡功率和雅可比矩阵。
计算不平衡功率时候，为了方便计算，我将各节点的不平衡功率放到一个一维数组里面。
雅可比矩阵的形成这一部分上我用了很长时间才将程序写出来。
首先是对角线上的H,N,J,L的计算公式写的很复杂，与同学讨论之后我发现可以先将每个节点的注入电流放到一个数组里面，这样后面用来求H,N,J,L时就比较方便。
在这一模块的过程中，我没有注意到雅克比矩阵中PQ节点和PV节点的对应关系，而且我没有将节点号取出来，以致出现了错误的编程思路和错误的结果，后来在同组同学的帮助下我又进行了第二次的编程，思路是正确的，但是运行出来的结果却是错误的，我想应该是我哪个公式出了错，最终经过反复检查后终于得到了正确结果，在编写雅克比矩阵还需要注意H、J、N、L四个矩阵的形成以及循环的顺序，然后就是如何将雅可比矩阵的各个元素放到一个二维数组里，这一部分看起来很简单，但是却很容易出错，经过和同组同学的认真思考和检查，终于得出来了正确的雅可比矩阵。
三、课程设计总结或结论
两周的潮流上机计算已经结束了，虽然时间很短，可是我却学到了很多。
潮流上机计算除了需要一定的电力系统稳态知识以外，还要有良好的C语言基础。
潮流上机的过程让我们巩固了潮流计算过程和方法，以及稳态的基础知识。
此外，从潮流数据的读入和写出，节点导纳矩阵的形成，功率不平衡量的计算，到形成雅克比矩阵和功率损耗的计算，我不断地进行编程和学习，在两周的潮流上机过程中，我完成了程序的编写，掌握了计算机潮流计算的基本方法与步骤，了解了计算机潮流计算的优点与重要性。
潮流计算最关键的是进行C语言的编程，没有良好的C语言基础很难快速地编出潮流计算程序，编写时需要注意循环和嵌套的使用，我在编写的过程中由于循环没有用好以及粗心等原因，导致多次编出来的程序出现错误，这在潮流计算中都是不应该出现的。
四、参考文献
1.《电力系统稳态分析》，陈珩，中国电力出版社，2007年，第三版；
2.《C语言程序设计》，郑玲，中国电力出版社，2009年，第一版；
附录（设计流程图、程序、表格、数据等）
1、设计流程图
是
否
2、程序
数据输入模块
structLine
{
intNum,NumI,NumJ;
floatR,X,B,K;
};
structBus
{
intNum;
floatVolt,Phase,GenP,GenQ,LoadP,LoadQ;
intType;
};
structShunt
{
intNum,NumI;
floatG,B;
};
#include"stdio.h"
#include"string.h"
#include"math.h"
#include"stdlib.h"
#defineNBUS4
#defineNLINE4
/*Globalvariables*/
intnL,nSH,nB,nVA;
floatX[NBUS];
intL;
voidmain（）
{
FILE*fp;
inti,j,k,l,h,c;
inti1,i2,i3;
floatd1,d2,d3,d4,d5,d6,r,x,g,b,e;
structLinesL[NLINE];
structBussB[NBUS];
structShuntsSH[NBUS];
floatYG[NBUS][NBUS],YB[NBUS][NBUS];
i1=i2=i3=0;
d1=d2=d3=d4=d5=d6=0.0;
e=0.00001;
for（i=0;i/*Readtheinputdata*/
if（（fp=fopen（"data.txt","r"））==NULL）
{printf（"Cannotopenthefilenamed'data.txt'\n"）;
exit（0）;
}
fscanf（fp,"%d,%d,%d",&nB,&nL,&nSH）;
for（i=0;isB[i].Num=sB[i].Type=0;sB[i].Volt=1.0;
sB[i].Phase=sB[i].GenP=sB[i].GenQ=sB[i].LoadP=sB[i].LoadQ=0.0;
fscanf（fp,"%d,%f,%f,%f,%f,%f,%f,%d",&i1,&d1,&d2,&d3,&d4,&d5,&d6,&i2）;
sB[i].Num=i1;sB[i].Volt=d1;sB[i].Phase=d2;sB[i].GenP=d3;sB[i].GenQ=d4;sB[i].LoadP=d5,sB[i].LoadQ=d6;sB[i].Type=i2;
};
for（i=0;isL[i].Num=sL[i].NumI=sL[i].NumJ=0;
sL[i].R=sL[i].X=sL[i].B=0.0;sL[i].K=1.0;
fscanf（fp,"%2d%3d%3d%f%f%f%f",&i1,&i2,&i3,&d1,&d2,&d3,&d4）;
sL[i].Num=i1;sL[i].NumI=i2;sL[i].NumJ=i3;sL[i].R=d1;sL[i].X=d2;sL[i].B=d3;sL[i].K=d4;
}
for（i=0;isSH[i].Num=sSH[i].NumI=0;sSH[i].G=sSH[i].B=0.0;
fscanf（fp,"%2d%3d%f",&i1,&i2,&d1）;
sSH[i].Num=i1;sSH[i].NumI=i2;sSH[i].B=d1;
}
if（fp!
=NULL）fclose（fp）;
/*MakeYMatrix*/
for（i=1;iYG[i][j]=0.0;
YB[i][j]=0.0;
};
for（l=0;li=sL[l].NumI;
j=sL[l].NumJ;
r=sL[l].R;
x=sL[l].X;
d1=r*r+x*x;
g=r/d1;
b=-x/d1;
if（fabs（sL[l].K-1.0）<0.000001）
{/*Normallinesortransformers*/
YG[i][i]=YG[i][i]+g;
YG[j][j]=YG[j][j]+g;
YB[i][i]=YB[i][i]+b+sL[l].B;
YB[j][j]=YB[j][j]+b+sL[l].B;
YG[i][j]=YG[i][j]-g;
YG[j][i]=YG[j][i]-g;
YB[i][j]=YB[i][j]-b;
YB[j][i]=YB[j][i]-b;
}
else
{/*abnormaltransformerratio*/
if（fabs（sL[l].B）>0.000001）
{
YG[i][i]=YG[i][i]+g/sL[l].B/sL[l].B;
YG[j][j]=YG[j][j]+g;
YB[i][i]=YB[i][i]+b/sL[l].B/sL[l].B;
YB[j][j]=YB[j][j]+b;
YG[i][j]=YG[i][j]-g/sL[l].B;
YG[j][i]=YG[j][i]-g/sL[l].B;
YB[i][j]=YB[i][j]-b/sL[l].B;
YB[j][i]=YB[j][i]-b/sL[l].B;
}
}
}
/*ChecktheYmatrix*/
if（（fp=fopen（"GGBB.txt","w"））==NULL）{
printf（"Cannotopenthefilenamed'GGBB.txt'\n"）;exit（0）;}
fprintf（fp,"---YMatrix---\n"）;
for（i=1;i0.000001）
fprintf（fp,"Y（%3d,%-3d）=（%10.5f,%10.5f）\n",i,j,YG[i][j],YB[i][j]）;
if（fp!
=NULL）fclose（fp）;
/*设定电压初值*/
floatV[NBUS][NBUS]={0};
for（i=1;iif（sB[i-1].Type==0）
{
V[i][0]=1.0;
V[i][1]=0.0;
}
for（i=1;iif（sB[i-1].Type==1）
{
V[i][0]=sB[i-1].Volt;
V[i][1]=0.0;
}
for（i=1;iif（sB[i-1].Type==2）
{
V[i][0]=（sB[i-1].Volt）*cos（sB[i-1].Phase）;//es
V[i][1]=（sB[i-1].Volt）*sin（sB[i-1].Phase）;//fs
}
//输出电压初值
if（（fp=fopen（"电压初值.txt","w"））==NULL）
{
printf（"Cannotopenthefilenamed'电压初值.txt'\n"）;
exit（0）;
}
fprintf（fp,"---电压初值---\n"）;
for（i=1;ifor（j=1;j<2;j++）
fprintf（fp,"Y（%2d）=（%10.5f,%10.5f）\n",i,V[i][0],V[i][1]）;
if（fp!
=NULL）fclose（fp）;
for（c=1;;c++）
{
/*计算偏移量*/
floatPQ[100][2]={0},dV[100]={0},df[100]={0};
for（i=1;i{
if（sB[i-1].Type==0）//计算PQ节点
{
for（j=1;j{
PQ[i][0]-=V[i][0]*（YG[i][j]*V[j][0]-YB[i][j]*V[j][1]）+V[i][1]*（YG[i][j]*V[j][1]+YB[i][j]*V[j][0]）;
PQ[i][1]-=V[i][1]*（YG[i][j]*V[j][0]-YB[i][j]*V[j][1]）-V[i][0]*（YG[i][j]*V[j][1]+YB[i][j]*V[j][0]）;
}
}
if（sB[i-1].Type==1）//计算PV节点
{
for（j=1;j{
PQ[i][0]-=V[i][0]*（YG[i][j]*V[j][0]-YB[i][j]*V[j][1]）+V[i][1]*（YG[i][j]*V[j][1]+YB[i][j]*V[j][0]）;
}
dV[i]=V[i][1]*V[i][1]+V[i][0]*V[i][0];
}
}
h=1;
for（i=1;i{
if（sB[i-1].Type==0）
{
df[h]=PQ[i][0]+sB[i-1].GenP-sB[i-1].LoadP;
h++;
df[h]=PQ[i][1]+sB[i-1].GenQ-sB[i-1].LoadQ;
h++;
}
if（sB[i-1].Type==1）
{
df[h]=PQ[i][0]+sB[i-1].GenP-sB[i-1].LoadP;
h++;
df[h]=sB[i-1].Volt*sB[i-1].Volt-dV[i];
h++;
}
}
/*输出偏移量*/
if（c==1）{
if（（fp=fopen（"第一次迭代偏移量.txt","w"））==NULL）
{
printf（"Cannotopenthefilenamed'第一次迭代偏移量.txt'\n"）;
exit（0）;
}
fprintf（fp,"---第一次迭代偏移量---\n"）;
for（i=1;ifprintf（fp,"df（%2d）=（%10.5f）\n",i,df[i]）;
if（fp!
=NULL）fclose（fp）;
}
/*计算雅克比矩阵*/
floatga[2*（NBUS-1）]={0},gb[2*（NBUS-1）]={0};
floatH[2*（NBUS-1）][2*（NBUS-1）]={0},J[2*（NBUS-1）][2*（NBUS-1）]={0},L[2*（NBUS-1）][2*（NBUS-1）]={0},N[2*（NBUS-1）][2*（NBUS-1）]={0},JJ[2*（NBUS-1）][2*（NBUS-1）]={0},R[2*（NBUS-1）][2*（NBUS-1）]={0},S[2*（NBUS-1）][2*（NBUS-1）]={0};
for（i=1;i{
for（j=1;j{
if（i==j）
{
ga[i]=-（PQ[i][0]*V[i][0]+PQ[i][1]*V[i][1]）/（V[i][0]*V[i][0]+V[i][1]*V[i][1]）;//计算a
gb[i]=-（PQ[i][0]*V[i][1]-PQ[i][1]*V[i][0]）/（V[i][0]*V[i][0]+V[i][1]*V[i][1]）;//计算b
H[i][i]=-V[i][0]*YB[i][i]+YG[i][i]*V[i][1]+gb[i];
N[i][i]=V[i][0]*YG[i][i]+YB[i][i]*V[i][1]+ga[i];
J[i][i]=-V[i][0]*YG[i][i]-YB[i][i]*V[i][1]+ga[i];
L[i][i]=V[i][1]*YG[i][i]-YB[i][i]*V[i][0]-gb[i];
R[i][i]=2*V[i][1];
S[i][i]=2*V[i][0];
}
else
{
H[i][j]=-V[i][0]*YB[i][j]+YG[i][j]*V[i][1];//非对角线元素正确。
N[i][j]=V[i][0]*YG[i][j]+YB[i][j]*V[i][1];
J[i][j]=-V[i][0]*YG[i][j]-YB[i][j]*V[i][1];
L[i][j]=-V[i][0]*YB[i][j]+YG[i][j]*V[i][1];
R[i][j]=0.0;
S[i][j]=0.0;
}
}
}
h=1;
for（i=1;i{
l=1;
if（sB[i-1].Type==0）
{
for（j=1;j{
JJ[h][l]=H[i][j];
l++;
JJ[h][l]=N[i][j];
l++;
}
h++;
l=1;
for（j=1;j{
JJ[h][l]=J[i][j];
l++;
JJ[h][l]=L[i][j];
l++;
}
h++;
}
l=1;
if（sB[i-1].Type==1）
{
for（j=1;j{
JJ[h][l]=H[i][j];
l++;
JJ[h][l]=N[i][j];
l++;
}
h++;
l=1;
for（j=1;j{
JJ[h][l]=R[i][j];
l++;
JJ[h][l]=S[i][j];
l++;
}
h++;
}
}
/*输出雅克比矩阵*/
if（c==1）{
if（（fp=fopen（"第一次迭代雅克比矩阵.txt","w"））==NULL）
{
printf（"Cannotopenthefilenamed'雅克比矩阵.txt'\n"）;
exit（0）;
}
fprintf（fp,"-------第一次迭代雅克比矩阵--------\n",c）;
fprintf（fp,""）;
for（i=1;i{
fprintf（fp,"%d\t\t",i）;
}
fprintf（fp,"\n"）;
for（i=1;i{
fprintf（fp,"%2d",i）;
for（j=1;j{
fprintf（fp,"%10.5f\t",JJ[i][j]）;
}
fprintf（fp,"\n"）;
}
if（fp!
=NULL）fclose（fp）;
}
/*高斯法求解方程组*/
floatU[100]={};
intLH[100]={};
floatt,d;
l=1;
for（i=1;i{
LH[i]=0;
}
for（k=1;k{
d=0.0;
for（j=k;j{
if（fabs（JJ[k][j]）>d）
{
d=fabs（JJ[k][j]）;//在一行中找到一个最大值赋值d,并用JS[K]记住这个最大值所在的列号
LH[k]=j;
}
}
if（fabs（d）<0.000001）//如果d的数值太小，做为被除数将带来很大的误差
{
l=0;
}
elseif（LH[k]!
=k）
{
for（i=1;i{
t=JJ[i][k];
JJ[i][k]=JJ[i][LH[k]];//进行列交换，让最大值始终在对角元上
JJ[i][LH[k]]=t;
}
}
if（l==0）
{
break;
}
for（j=k+1;j{
JJ[k][j]=JJ[k][j]/JJ[k][k];//对角元上的元素消为
}
df[k]=df[k]/JJ[k][k];
for（i=k+1;i{
for（j=k+1;j{
JJ[i][j]=JJ[i][j]-JJ[i][k]*JJ[k][j];//使下三角阵的元素为
}
df[i]=df[i]-JJ[i][k]*df[k];
}
}
if（fabs（JJ[h-1][h-1]）>0.00001）
{//用追赶法，解方程组，求未知数x
升级会员 