华北电力大学潮流计算上机实验概要.docx
《华北电力大学潮流计算上机实验概要.docx》由会员分享，可在线阅读，更多相关《华北电力大学潮流计算上机实验概要.docx（32页珍藏版）》请在冰豆网上搜索。
华北电力大学潮流计算上机实验概要
《电力系统潮流上机》课程设计报告
院系：
电气与电子工程学院
班级：
电气1006
学号
学生姓名：
*******
设计周数：
两周
成绩：
日期：
2013年1月10日
一、目的与要求
培养学生的电力系统潮流计算机编程能力，掌握计算机潮流计算的相关知识
二、主要内容
1．手算.要求应用牛顿-拉夫逊法或P-Q分解法手算求解，要求精度为0.001MW。
节点1为平衡节点，电压
，节点2为PQ节点，负荷功率
，节点3是PV节点，
，两条支路分别为
，
，对地支路
。
2．计算机计算（详见附录）
3．思考题
3.1潮流计算的方法有哪些？
各有何特点？
答：
潮流计算分为手算和机算两大类，其中机算又有高斯-赛德尔迭代法、牛顿-拉夫逊迭代法、P-Q分解法等算法。
迭特点：
手算求解潮流一般只用在简单的网络中，其计算量大，对于多节点的网络用手算一般难以解决问题，但通过手算可以加深物理概念的理解，还可以在运用计算机计算前以手算求取某些原始数据。
高斯-赛德尔迭代法：
算法简单，对初值的要求不高，但需要迭代的次数多，收敛的速度慢，在早期的潮流计算程序中应用很多，之后逐渐被牛顿-拉夫逊迭代法所取代，但仍可作为计算程序前几次迭代的算法，以弥补后者对初值要求高的缺点。
牛顿-拉夫逊迭代法：
是常用的解非线性方程组的方法，也是当前广泛采用的计算潮流的方法，其收敛速度快，几次迭代就可以得到最终的结果。
但其缺点是要求初值的选择得比较接近它们的精确值，否则迭代过程可能不收敛。
P-Q分解法潮流计算：
派生于以极坐标表示时的牛顿-拉夫逊法，其根据电力系统的特点，对后者的修正方程做了简化，P-Q分解法的系数矩阵B’和B”代替了牛拉法中的雅可比矩阵J，阶数降低，其中的元素在迭代过程中不发生变化，而且元素对称，这些都大大提高了运算速度，而且精确度几乎不受影响。
P-Q分解法的收敛特性接近于直线，而牛顿-拉夫逊的收敛速度要比P-Q分解法快，
但是由于牛顿-拉夫逊每次迭代都要形成雅客比矩阵，所以一次代的时间比P-Q分解法长。
3.2如果交给你一个任务，请你用已有的潮流计算软件计算北京城市电网的潮流，你应该做哪些工作？
（收集哪些数据，如何整理，计算结果如何分析
答：
（1）所需要收集的数据：
A.电网中所有节点的数据：
a．各节点的类型,包括平衡节点、PV节点、PQ节点；b.对于平衡节点要了解节点的电压大小相位、及节点所能提供的最大最小有功无功功率；c.PV节点要知道节点电压大小注入有功功率及节点所能提供的最大和最小无功功.率；d.PQ节点要知道节点的注入有功和无功功率
B．电网中所有支路的数据：
a.各支路类型，即是否含有变压器；b.各支路的电阻、电感、电纳；c.各变压器的变比。
（2）数据整理：
将上述数据资料进行分类整理，并为每个节点及支路编上编号。
将整理的结果写成本实验中所要求的格式（原始数据的txt文档），再用本实验所编制的程序进行求解，得到各节点电压、相位，各线路传输功率、损耗，平衡节点注入功率等数值。
（3）计算结果分析：
可以大致了解整个电网的运行状况并按照电力系统知识依次进行所需的调整。
如调节各节点电压的大小以防止超出规定限度，调整各线路的有功无功分布状况分析整个系统的网损是否达到标准等。
3.3设计中遇到的问题和解决的办法。
1）设计中遇到是对C++部分指令的不熟悉，通过老师讲解、看书和向他人询问减小了编程语言上的障碍；
2）在设计中，由于一开始知识脉络以及思维脉络都不是很清晰，导致在程序设计过程中的各种误操作，例如在写不平衡量的时候对定义数组的下脚标标注不清。
最好经过老师的教导和我们自己的仔细排查，终于排除掉各类错误，得到结果。
在形成雅克比矩阵的过程中，存在雅克比矩阵的坐标与节点的坐标对应和转化的问题。
附录（设计流程图、程序、表格、数据等）
一、流程图
二、程序
/*
Purpose:
forundergraduatepowerflowcalculationcourse
Example2
Author:
SunYingyun
Date:
9-Jun-2010
Version:
1.0.0
Thisclassistohelpthestudentstosolvepfproblems.
*/
#include"pf.h"
usingnamespacestd;
pf:
:
pf（void）
{
m_Line=NULL;
m_Bus=NULL;
m_Bus_newIdx=NULL;
m_pv_Num=0;
m_sw_Num=0;
m_pq_Num=0;
}
pf:
:
~pf（void）
{
if（m_Line!
=NULL）delete[]m_Line;
if（m_Bus!
=NULL）delete[]m_Bus;
if（m_Bus_newIdx!
=NULL）delete[]m_Bus_newIdx;
}
intpf:
:
readDataFromFile（stringfileName）
{
stringstrLine,strTemp;
ifstreamfin;
//openfileforread;
fin.open（fileName.c_str（））;
if（!
fin.fail（））
{
//1.readSBase;
getline（fin,strLine）;
strTemp.assign（strLine,31,6）;
m_SBase=atof（strTemp.c_str（））;
//2.readBusDatahere;
//2.1readBusnum;
getline（fin,strLine）;
size_tpos_begin,pos_end;
pos_begin=strLine.find（"FOLLOWS"）;
pos_begin=pos_begin+size_t（10）;
pos_end=strLine.find（"ITEM"）;
strTemp=strLine.substr（pos_begin,pos_end-pos_begin）;
m_Bus_Num=atoi（strTemp.c_str（））;//读入节点个数
cout<<"系统共有"<cout<<"Type"<<<"LoadP"<<<"GenP"<<//2.2readeachbusdatahere
//allocatememoryform_Bus（为节点数据定义数组）
m_Bus=newBus[m_Bus_Num];//建立结构体保存节点数据
m_Bus_newIdx=newint[m_Bus_Num];
for（inti=0;i{
getline（fin,strLine）;
strTemp=strLine.substr（0,4）;
//readbusnum
m_Bus[i].Num=atoi（strTemp.c_str（））;
//readbusName;
strTemp=strLine.substr（5,7）;
m_Bus[i].Name=strTemp;
//readbustypePQ:
Type=1;PV:
Type=2;swing:
Type=3;
strTemp=strLine.substr（24,2）;
if（atoi（strTemp.c_str（））<=1）
{
m_Bus[i].Type=1;
m_pq_Num++;
}
elseif（atoi（strTemp.c_str（））==2）
{
m_Bus[i].Type=2;
m_pv_Num++;
}
elseif（atoi（strTemp.c_str（））==3）
{
m_Bus[i].Type=3;
m_sw_Num++;
}
strTemp=strLine.substr（27,6）;
m_Bus[i].V=atof（strTemp.c_str（））;//读入节点电压V
strTemp=strLine.substr（33,6）;
m_Bus[i].theta=atof（strTemp.c_str（））;//读入节点相角
strTemp=strLine.substr（39,9）;
m_Bus[i].LoadP=atof（strTemp.c_str（））;//读入节点有功负荷
strTemp=strLine.substr（49,10）;
m_Bus[i].LoadQ=atof（strTemp.c_str（））;//读入节点无功负荷
strTemp=strLine.substr（59,8）;
m_Bus[i].GenP=atof（strTemp.c_str（））;//读入节点电压V
strTemp=strLine.substr（67,8）;
m_Bus[i].GenQ=atof（strTemp.c_str（））;//读入节点电压V
strTemp=strLine.substr（114,8）;
m_Bus[i].ShuntB=atof（strTemp.c_str（））;//inputintoShuntBinsystem
strTemp=strLine.substr（106,8）;
m_Bus[i].ShuntG=atof（strTemp.c_str（））;//inputintoShuntGinsystem
cout<<<<}
//3.readLineDatahere;
//3.1readLinenum;
getline（fin,strLine）;
getline（fin,strLine）;
pos_begin=strLine.find（"FOLLOWS"）;
pos_begin=pos_begin+size_t（10）;
pos_end=strLine.find（"ITEM"）;
strTemp=strLine.substr（pos_begin,pos_end-pos_begin）;
m_Line_Num=atoi（strTemp.c_str（））;
m_Line=newLine[m_Line_Num];
for（inti=0;i{
getline（fin,strLine）;
strTemp=strLine.substr（0,4）;
m_Line[i].NumI=atoi（strTemp.c_str（））;
strTemp=strLine.substr（5,4）;
m_Line[i].NumJ=atoi（strTemp.c_str（））;//readline
strTemp=strLine.substr（19,10）;
m_Line[i].R=atof（strTemp.c_str（））;//readbusR;
strTemp=strLine.substr（29,10）;
m_Line[i].X=atof（strTemp.c_str（））;//readbusX;
strTemp=strLine.substr（40,11）;
m_Line[i].B=atof（strTemp.c_str（））;//readbusB;
m_Line[i].K=1;//readbusK;
strTemp=strLine.substr（18,1）;
m_Line[i].Type=atoi（strTemp.c_str（））;//readbusType
}
//4.closethefile;
fin.close（）;
}
else
cout<<"fileopenfail!
"<
return0;
}
//重新编号pq、pv、sw
intpf:
:
initPFData（）
{
//accordingtoPage132ofrefbook3,
//reindexthebusnumasethesequence[PQPVSW];
intiPQ,iPV,iSW;
iPQ=0;
iPV=0;
iSW=0;
inti;
for（i=0;i{
switch（m_Bus[i].Type）
{
case1:
m_Bus_newIdx[i]=iPQ;
iPQ++;
break;
case2:
m_Bus_newIdx[i]=iPV+m_pq_Num;
iPV++;
break;
case3:
m_Bus_newIdx[i]=iSW+m_pq_Num+m_pv_Num;
iSW++;
break;
}
}
for（i=0;icout<//herewegivethesizeofJacobimatrix;
//分别给出jacobi矩阵和B\G矩阵的空间
m_Jacobi.setSize（2*m_pq_Num+m_pv_Num,2*m_pq_Num+m_pv_Num）;
m_Matrix_B.setSize（m_Bus_Num,m_Bus_Num）;
m_Matrix_G.setSize（m_Bus_Num,m_Bus_Num）;
return0;
}
//
intpf:
:
getBusIdx（intbusNum）
{
//returntheindexofbusfrombusNum
inti,idx=-1;
for（i=0;i{
if（m_Bus[i].Num==busNum）
idx=i;
}
returnidx;
}
//做jacobi矩阵
intpf:
:
makeYMatrix（）
{
//做导纳矩阵
intii,jj;
doubleYG,YB;
doubleZ2;
for（inti=0;i{
ii=m_Line[i].NumI-1;
jj=m_Line[i].NumJ-1;
Z2=m_Line[i].R*m_Line[i].R+m_Line[i].X*m_Line[i].X;
YG=m_Line[i].R/Z2;
YB=-1*m_Line[i].X/Z2;
m_Matrix_G（ii,ii）+=YG;
m_Matrix_B（ii,ii）+=YB+m_Line[i].B/2;
m_Matrix_G（jj,jj）+=YG;
m_Matrix_B（jj,jj）+=YB+m_Line[i].B/2;
m_Matrix_G（ii,jj）-=YG;
m_Matrix_B（ii,jj）-=YB;
m_Matrix_G（jj,ii）-=YG;
m_Matrix_B（jj,ii）-=YB;
}
m_Matrix_B.outputMatrix（）;
m_Matrix_G.outputMatrix（）;
return0;
}
//做jacobi矩阵
intpf:
:
makeJacobi（）
{
//TODO
inti,j,k=0,l=0,n=0,h;
structBusa[9];
intb[9];
for（i=0;i{
if（m_Bus[i].Type==1）
{
a[k]=m_Bus[i];
b[k]=i;
k++;
}
if（m_Bus[i].Type==2）
{
a[l+m_pq_Num]=m_Bus[i];
b[l+m_pq_Num]=i;
l++;
}
if（m_Bus[i].Type==3）
{
a[n+m_pq_Num+m_pv_Num]=m_Bus[i];
b[n+m_pq_Num+m_pv_Num]=i;
n++;
}
}
//计算jacobi矩阵中A区元素
for（i=0;i{
for（j=0;j{
if（i==j）
{
for（h=0;h{
if（h!
=i）
{
m_Jacobi（2*i,2*i）+=a[i].V*a[h].V*（m_Matrix_G（b[i],b[h]）*sin（a[i].theta*3.14/180-a[h].theta*3.14/180）-m_Matrix_B（b[i],b[h]）*cos（a[i].theta*3.14/180-a[h].theta*3.14/180））;
m_Jacobi（2*i,2*i+1）-=a[i].V*a[h].V*（m_Matrix_G（b[i],b[h]）*cos（a[i].theta*3.14/180-a[h].theta*3.14/180）+m_Matrix_B（b[i],b[h]）*sin（a[i].theta*3.14/180-a[h].theta*3.14/180））;
m_Jacobi（2*i+1,2*i）-=a[i].V*a[h].V*（m_Matrix_G（b[i],b[h]）*cos（a[i].theta*3.14/180-a[h].theta*3.14/180）+m_Matrix_B（b[i],b[h]）*sin（a[i].theta*3.14/180-a[h].theta*3.14/180））;
m_Jacobi（2*i+1,2*i+1）-=a[i].V*a[h].V*（m_Matrix_G（b[i],b[h]）*sin（a[i].theta*3.14/180-a[h].theta*3.14/180）-m_Matrix_B（b[i],b[h]）*cos（a[i].theta*3.14/180-a[h].theta*3.14/180））;
}
else
continue;
}
m_Jacobi（2*i,2*i+1）-=2*a[i].V*a[i].V*m_Matrix_G（b[i],b[i]）;
m_Jacobi（2*i+1,2*i+1）+=2*a[i].V*a[i].V*m_Matrix_B（b[i],b[i]）;
}
else
{
m_Jacobi（2*i,2*j）=-a[i].V*a[j].V*（m_Matrix_G（b[i],b[j]）*sin（a[i].theta*3.14/180-a[j].theta*3.14/180）-m_Matrix_B（b[i],b[j]）*cos（a[i].theta*3.14/180-a[j].theta*3.14/180））;
m_Jacobi（2*i,2*j+1）=-a[i].V*a[j].V*（m_Matrix_G（b[i],b[j]）*cos（a[i].theta*3.14/180-a[j].theta*3.14/180）+m_Matrix_B（b[i],b[j]）*sin（a[i].theta*3.14/180-a[j].theta*3.14/180））;
m_Jacobi（2*i+1,2*j）=a[i].V*a[j].V*（m_Matrix_G（b[i],b[j]）*cos（a[i].theta*3.14/180-a[j].theta*3.14/180）+m_Matrix_B（b[i],b[j]）*sin（a[i].theta*3.14/180-a[j].theta*3.14/180））;
m_Jacobi（2*i+1,2*j+1）=-a[i].V*a[j].V*（m_Matrix_G（b[i],b[j]）*sin（a[i].theta*3.14/180-a[j].theta*3.14/180）-m_Matrix_B（b[i],b[j]）*cos（a[i].theta*3.14/180-a[j].theta*3.14/180））;
}
}
}
//计算jacobi矩阵中B区的元素
for（i=k;i{
for（j=k;j{
if（i
升级会员 