华北电力大学潮流上机课程设计报告

课程设计报告
( 2011-- 2012年度第一学期)
名称：电力系统潮流上机院系：电气与电子工程学院班级：电管0902
学号：1091140202 学生：
指导教师：麻秀
设计周数：两周
成绩：
日期：2011年1月6日
一、课程设计的目的与要求
培养学生的电力系统潮流计算机编程能力，掌握计算机潮流计算的相关知识
二、设计正文（详细容见附录）
1、手算
在此我们同样采取计算机计算这种方便快捷的方法。

具体的方法及结果见附录。

2、计算机计算
通过计算机编程，我们可以很方便的求解出相关量，其具体计算方法及计算结果见附录。

3、思考题答案见附录。

三、课程设计总结或结论
潮流计算是研究电力系统稳态运行的一种基本运算方法，通过对于潮流的计算，实现对潮流的控制，维护电力系统稳定，防止出现超过约束条件的情况，从而使电力系统免遭崩溃的危险。

最初求解电力系统潮流时大多是用手算，这种计算方法不但耗费时间长，精度差，而且对于大容量的电力系统无法做到很好的控制。

随着电力系统结构日趋复杂，计算量也越来越大，仅靠手算难以求解一些复杂网络的潮流。

计算机作为一种处理数据的工具，其计算速度快，准确率高，存储量大，因此它广泛的应用于大规模复杂化的电力系统网络中。

为了能使计算机能进行潮流计算，就必须编制相应的程序，使其能按照人们在程序中设定的计算流程一步一步的执行，直到计算结果达到要求的精度，得到最终想要的结果。

C语言是一种简单实用的语言，利用它进行程序设计可以大大提高电力系统潮流控制的自动化程度。

本次的潮流上机，就是要求我们利用C语言编程，进行计算机潮流计算。

这既是对我们电力系统潮流计算知识的考验，也是对我们C语言编程能力的考验。

是一次各种知识的交汇综合的运用。

通过这次潮流上机，我对电力系统潮流计算有了更深刻的认识，同时，我的C语言编程能力也得到了提高。

我明白了学习不能仅限于课本，还要做到“学以致用”的道理。

在这次潮流设计中，我遇到了由于多问题，其中既包括由于对潮流知识掌握不牢而导致的问题，也包括由于C语言编程能力有限而导致的问题。

幸而在麻老师、学姐和同学们的帮助下，这些问题都得到一一解决。

在这里，我要衷心的感老师们的辛苦付出！
参考文献
1.《电力系统计算：电子数字计算机的应用》，交通大学等合编。

：水利电力；
2.《现代电力系统分析》，王锡凡主编，科学；
3.《电力系统稳态分析》，珩，中国电力，2007年，第三版；
附录（包括：1.手算过程及结果；2.计算机计算流程图；3、表格、数据；4、思考题答案；5、程序）1、结果
题1：
题2：
2、流程图如下：
3、原始数据及表格
3.1各节点原始数据：
注：上表中，1为PQ节点，2为PV节点，3为平衡节点。

3.2各线路原始数据
注：上表中，变压器变比为0表示该线路上没有变压器。

4、思考题答案：
3.1潮流计算的方法有哪些？各有何特点？
答：
潮流计算目前主要的计算方法有：高斯-赛德尔迭代法、牛顿拉夫逊法和P-Q分解法。

它们各自的特点如下：
1、高斯-赛德尔法
分为以节点导纳矩阵为基础的迭代法和以节点阻抗矩阵为基础的迭代法。

前者原理较为简单，占用的计算机存也较少，但收敛性较差，随着计算量的增加，迭代次数不断上升，往往出现迭代不收敛的情况；而节点阻抗矩阵改善了电力系统潮流计算的收敛性问题，在当时得到了广泛的应用，但是它的缺点是占用计算机存比较大，每次迭代的计算量也很大。

当系统逐渐增大时这个问题会变得更加突出。

2、牛顿拉夫逊法
它是数学上典型的收敛性求法，具有较好的收敛性，只要能保证方程式系数矩阵的稀疏性，就能大大提高这种方法的计算效率，牛顿拉夫逊法在占用存和计算次数与速度上都优于高斯赛德尔法，现在仍在广泛应用。

3、P-Q分解法
这种方法派生于以极坐标表示的牛顿拉夫逊法。

与牛顿拉夫逊法相比，P-Q分解法的修正方程式的系数矩阵B’和B’’分别以（n-1）和(m-1)的方阵，代替了(n+m-2)阶的系数矩阵；并且B’和B’’在迭代过程中保持不变，并且自身对称，提高了计算速度，降低了对存储容量的要求，在计算速度上得到了显著的提高，得到了广泛的应用。

3.2如果交给你一个任务，请你用已有的潮流计算软件计算城市电网的潮流，你应该做哪些工作？（收集哪些数据，如何整理，计算结果如何分析）
答：第一步首先要了解城市电网的所有节点类型，统计不同节点类型的数据。

在处理PQ类节点时要得到注入有功功率和注入无功功率的数据；PV类节点要得到节点电压的大小、注入的有功功率以及节点能提供的最大和最小无功功率；对于平衡节点要得到节点电压大小及相位，以及节点所能提供的最大和最小无功、有功功率。

第二步应得到支路的电阻电抗大小、变压器的变比以及线路最大的传输容量。

第三步应考虑分析PQ节点的电压大小是否满足约束条件；分析PV节点的电压大小以及无功功率是否满足约束条件，注意PV节点向PQ节点转化的问题；分析平衡节点所提供的有功无功功率是否满足约束条件，在规定的围；分析线路上的传输功率是否符合要求；分析全网的网络损耗是否在标准围。

3.3设计中遇到的问题和解决的办法
潮流上机编程是一次对我们电力系统分析知识掌握程度和C语言编程能力的综合考验。

在这次潮流上机的过程中，我遇到了许多问题。

幸而在老师和学姐的帮助下，许多问题才得以迎刃而解。

潮流设计中遇到的主要问题总结如下：
1、对电力系统分析知识掌握不够熟练，导致许多时候编程出现了许多问题。

对于因对电力系统知识掌握不熟而导致的错误，只有仔细看书，把概念理解熟透，再西斯对照课本，确保编程无误。

通过解决编程中出现的问题，加深我对电力系统知识的理解。

亡羊补牢，为时未晚。

2、C语言编程能力还有待提高。

C语言系大一时所学，时至今日，能记得的知识所剩无几。

许多编程方法只能根据老师提供的模板，依样画瓢，缺乏深刻的理解。

在C语言编程的过程中，最困难的部分不是编程，而是调试。

调试的过程是对我们逻辑思维能力的极大的考验，我们必须详尽的考虑到种种逻辑结构问题，才能确保函数的逻辑意义明确，表达清晰。

通过对程序的调试，提高了我的C语言编程能力，而且让我对C语言的各种调试工具有了更进一步的
5、9节点程序
// flow.cpp : Defines the entry point for the console application.
//
#include "StdAfx.h"
#include <iostream.h>
#include <fstream.h>
#include "NEquation.h"
#include "math.h"
#include "config.h"
void test()
{
NEquation ob1;
ob1.SetSize(2);
ob1.Data(0,0)=1;
ob1.Data(0,1)=2;
ob1.Data(1,0)=2;
ob1.Data(1,1)=1;
ob1.Value(0)=5;
ob1.Value(1)=4;
ob1.Run();
printf("x1=%f\n",ob1.Value(0));
printf("x2=%f\n",ob1.Value(1));
}
void GetData()//Read the data
{
FILE *fp;
int i;
if((fp=fopen("C:\\Documents and Settings\\Administrator\\桌面\\1091140202 小磊\\9节点\\程序模板\\data\\data.txt","r"))==NULL)
{
printf("Can not open the file named 'data.txt' \n");
return;
}
for(i=0;i<=Bus_Num-1;i++)
{
fscanf(fp,"%d,%f,%f,%f,%f,%f,%f,%d",&gBus[i].No,&gBus[i].Voltage,&gBus[i].Phase,
}
for(i=0;i<=Line_Num-1;i++)
{
fscanf(fp,"%d,%d,%d,%f,%f,%f,%f",&gLine[i].No,&gLine[i].No_I,&gLine[i].No_J, &gLine[i].R,&gLine[i].X,&gLine[i].B,&gLine[i].k);
}
fclose(fp);
}
void GetYMatrix()
{
int i,j;
FILE *fp;
// calculate the Y matrix
int bus1,bus2;
float r,x,d,g,b,g1,b1,g2,b2,g3,b3;
for(i=0;i<=Bus_Num-1;i++)
{
for(j=0;j<=Bus_Num-1;j++)
{
gY_G[i][j]=0;
gY_B[i][j]=0;
}
}
for(i=0; i<=Line_Num-1; i++)
{
if(gLine[i].k==0)
{
bus1=gLine[i].No_I-1;
bus2=gLine[i].No_J-1;
r=gLine[i].R;
x=gLine[i].X;
d=r*r+x*x;
g=r/d;
b=-x/d;
gY_G[bus1][bus1]=gY_G[bus1][bus1]+g;
gY_G[bus2][bus2]=gY_G[bus2][bus2]+g;
gY_G[bus2][bus1]=gY_G[bus2][bus1]-g;
gY_B[bus1][bus1]=gY_B[bus1][bus1]+b+gLine[i].B;
gY_B[bus2][bus2]=gY_B[bus2][bus2]+b+gLine[i].B;
gY_B[bus1][bus2]=gY_B[bus1][bus2]-b;
gY_B[bus2][bus1]=gY_B[bus2][bus1]-b;
}
else
{
bus1=gLine[i].No_I-1;
bus2=gLine[i].No_J-1;
r=gLine[i].R;
x=gLine[i].X;
d=r*r+x*x;
g=r/d;
b=-x/d;
g1=g/gLine[i].k;
b1=b/gLine[i].k;
g2=g*(1-gLine[i].k)/(gLine[i].k*gLine[i].k);
b2=b*(1-gLine[i].k)/(gLine[i].k*gLine[i].k);
g3=g*(gLine[i].k-1)/gLine[i].k;
b3=b*(gLine[i].k-1)/gLine[i].k;
gY_G[bus1][bus1]=gY_G[bus1][bus1]+g1+g2;
gY_G[bus2][bus2]=gY_G[bus2][bus2]+g1+g3;
gY_G[bus1][bus2]=gY_G[bus1][bus2]-g1;
gY_G[bus2][bus1]=gY_G[bus2][bus1]-g1;
gY_B[bus1][bus1]=gY_B[bus1][bus1]+b1+b2;
gY_B[bus2][bus2]=gY_B[bus2][bus2]+b1+b3;
gY_B[bus1][bus2]=gY_B[bus1][bus2]-b1;
gY_B[bus2][bus1]=gY_B[bus2][bus1]-b1;
}
}
// output the Y matrix
if((fp=fopen("C:\\Documents and Settings\\Administrator\\桌面\\1091140202 小磊\\9节点\\程序模板\\data\\ymatrix.txt","w"))==NULL)
{
printf("Can not open the file named 'ymatrix.txt' \n");
return ;
}
fprintf(fp,"---Y Matrix---\n");
for(i=0;i<=Bus_Num-1;i++)
{
for(j=0;j<=Bus_Num-1;j++)
fprintf(fp,"Y(%d,%d)=(%10.5f,%10.5f)\n",i+1,j+1,gY_G[i][j],gY_B[i][j]);
}
}
fclose(fp);
}
void SetInitial()
{
int i;
for(i=0;i<=Bus_Num-1;i++)
{
gf[i]=gBus[i].Voltage*sin(gBus[i].Phase);
ge[i]=gBus[i].Voltage*cos(gBus[i].Phase);
}
}
void GetUnbalance()
{
int i,j;
float Sum_P=0,Sum_Q=0;
FILE *fp;
for(i=1;i<=Bus_Num-1;i++)
{
Sum_P=0,Sum_Q=0; //循环前清空SumP和SumQ
for(j=0;j<=Bus_Num-1;j++)
{
Sum_P+=(ge[i]*(gY_G[i][j]*ge[j]-gY_B[i][j]*gf[j])+gf[i]*(gY_G[i][j]*gf[j]+gY_B[i][j]*ge [j])); //求和
Sum_Q+=(gf[i]*(gY_G[i][j]*ge[j]-gY_B[i][j]*gf[j])-ge[i]*(gY_G[i][j]*gf[j]+gY_B[i][j]*ge [j])); //求和
}
if(gBus[i].Type==1) //PQ节点
{
gDelta_P[i-1]=(gBus[i].GenP-gBus[i].LoadP)-Sum_P;
gDelta_Q[i-1]=(gBus[i].GenQ-gBus[i].LoadQ)-Sum_Q;
}
if(gBus[i].Type==2) //PV节点
{
gDelta_P[i-1]=(gBus[i].GenP-gBus[i].LoadP)-Sum_P;
gDelta_Q[i-1]=gBus[i].Voltage*gBus[i].Voltage-(ge[i]*ge[i]+gf[i]*gf[i]);
}
}
//合并gDelta_P,gDelta_Q至gDelta_PQ
for(i=0;i<=Bus_Num-2;i++)
{
gDelta_PQ[2*i]=gDelta_P[i];
gDelta_PQ[2*i+1]=gDelta_Q[i];
}
if((fp=fopen("C:\\Documents and Settings\\Administrator\\桌面\\1091140202 小磊\\9节点\\程序模板\\data\\unbalance.txt","w"))==NULL)
{
printf("Can not open the file named 'unbalance.txt' \n");
return ;
}
fprintf(fp,"---Unbalance---\n");
for(i=0;i<=2*Bus_Num-3;i++)
{
fprintf(fp,"Unbalance[%d]=%10.5f\n",i+1,gDelta_PQ[i]);
}
fclose(fp);
}
void GetJaccobi()
{
int i,j;
float H[Bus_Num-1][Bus_Num-1],N[Bus_Num-1][Bus_Num-1];
float J[Bus_Num-1][Bus_Num-1],L[Bus_Num-1][Bus_Num-1];
float A[Bus_Num-1],B[Bus_Num-1];
FILE *fp;
//赋初值
for(i=0;i<=Bus_Num-2;i++)
{
for(j=0;j<=Bus_Num-2;j++)
{
H[i][j]=0;
N[i][j]=0;
L[i][j]=0;
J[i][j]=0;
}
A[i]=0;
B[i]=0;
}
//计算注入电流
for(i=0;i<=Bus_Num-2;i++)
{
for(j=0;j<=Bus_Num-1;j++)
{
A[i]+=gY_G[i+1][j]*ge[j]-gY_B[i+1][j]*gf[j];
B[i]+=gY_G[i+1][j]*gf[j]+gY_B[i+1][j]*ge[j];
}
}
for(i=0;i<=Bus_Num-2;i++)
{
for(j=0;j<=Bus_Num-2;j++)
{
if(i!=j) //i!=j时
{
if(gBus[i+1].Type==1) //若是PQ节点
{
H[i][j]=-gY_B[i+1][j+1]*ge[i+1]+gY_G[i+1][j+1]*gf[i+1];
N[i][j]=gY_B[i+1][j+1]*gf[i+1]+gY_G[i+1][j+1]*ge[i+1];
J[i][j]=-N[i][j];
L[i][j]=H[i][j];
}
if(gBus[i+1].Type==2) //若是PV节点
{
H[i][j]=-gY_B[i+1][j+1]*ge[i+1]+gY_G[i+1][j+1]*gf[i+1];
N[i][j]=gY_B[i+1][j+1]*gf[i+1]+gY_G[i+1][j+1]*ge[i+1];
J[i][j]=0;
L[i][j]=0;
}
}
if(i==j) //i=j时
{
if(gBus[i+1].Type==1) //若是PQ节点
{
H[i][j]=-gY_B[i+1][j+1]*ge[i+1]+gY_G[i+1][j+1]*gf[i+1]+B[i];
N[i][j]=gY_G[i+1][j+1]*ge[i+1]+gY_B[i+1][j+1]*gf[i+1]+A[i];
J[i][j]=-gY_G[i+1][j+1]*ge[i+1]-gY_B[i+1][j+1]*gf[i+1]+A[i];
L[i][j]=-gY_B[i+1][j+1]*ge[i+1]+gY_G[i+1][j+1]*gf[i+1]-B[i];
}
if(gBus[i+1].Type==2) //若是PV节点
{
H[i][j]=-gY_B[i+1][j+1]*ge[i+1]+gY_G[i+1][j+1]*gf[i+1]+B[i];
N[i][j]=gY_G[i+1][j+1]*ge[i+1]+gY_B[i+1][j+1]*gf[i+1]+A[i];
J[i][j]=2*gf[i+1];
L[i][j]=2*ge[i+1];
}
}
}
}
//合并
for(i=0;i<=Bus_Num-2;i++)
{
for(j=0;j<=Bus_Num-2;j++)
{
gJaccobi[2*i][2*j]=H[i][j];
gJaccobi[2*i][2*j+1]=N[i][j];
gJaccobi[2*i+1][2*j]=J[i][j];
gJaccobi[2*i+1][2*j+1]=L[i][j];
}
}
//将数据写入文件
if((fp=fopen("C:\\Documents and Settings\\Administrator\\桌面\\1091140202 小磊\\9节点\\程序模板\\data\\jaccobi.txt","w"))==NULL)
{
printf("Can not open the file named 'jaccobi.txt' \n");
return ;
}
fprintf(fp,"---Jaccobi Matrix---\n");
for(i=0;i<=2*Bus_Num-3;i++)
{
for(j=0;j<=2*Bus_Num-3;j++)
{
fprintf(fp,"jaccobi(%d,%d)=%10.5f\n",i+1,j+1,gJaccobi[i][j]);
}
}
fclose(fp);
}
void GetRevised()
{
int i,j;
FILE *fp;
NEquation ob1;
ob1.SetSize(2*(Bus_Num-1));
for(i=0;i<=2*Bus_Num-3;i++)
{
for(j=0;j<=2*Bus_Num-3;j++)
{
ob1.Data(i,j)=gJaccobi[i][j];
}
ob1.Value(i)=gDelta_PQ[i];
}
ob1.Run();
for(i=0;i<=2*Bus_Num-3;i++)
{
gDelta_fe[i]=ob1.Value(i);
}
//写入数据
if((fp=fopen("C:\\Documents and Settings\\Administrator\\桌面\\1091140202 小磊\\9节点\\程序模板\\data\\revised.txt","w"))==NULL)
{
printf("Can not open the file named 'revised.txt' \n");
return ;
}
fprintf(fp,"---Revised---\n");
for(i=0;i<=2*Bus_Num-3;i++)
{
fprintf(fp,"revised[%d]=%10.5f\n",i+1,gDelta_fe[i]);
}
fclose(fp);
}
void GetNewValue()
{
int i,j=0;
FILE *fp;
for(i=0;i<=Bus_Num-1;i++)
{
if(gBus[i].Type!=3)
{
gDelta_f[j]=gDelta_fe[2*j];
gf[i]+=gDelta_f[j];
gDelta_e[j]=gDelta_fe[2*j+1];
ge[i]+=gDelta_e[j];
j++;
}
}
//写入数据
if((fp=fopen("C:\\Documents and Settings\\Administrator\\桌面\\1091140202 小磊\\9节点\\程序模板\\data\\newvalue.txt","w"))==NULL)
{
printf("Can not open the file named 'newvalue.txt' \n");
return ;
}
fprintf(fp,"---New Value---\n");
for(i=0;i<=Bus_Num-2;i++)
{
fprintf(fp,"f(%d)=%10.5f,e(%d)=%10.5f\n",i+1,gf[i+1],i+1,ge[i+1]);
}
fclose(fp);
}
void GetS() //各个节点的注入功率情况
{
int i,j;
float Ps,Qs; //平衡节点的有功无功
float Qv=0; //PV节点的无功
float Sum1=0,Sum2=0;
printf("\n\n********各个节点的注入功率情况**********\n\n");
for(i=0;i<=Bus_Num-1;i++)
{
if(gBus[i].Type==3)
{
for(j=0;j<=Bus_Num-1;j++)
{
Sum1+=gY_G[i][j]*ge[j]-gY_B[i][j]*gf[j];
Sum2+=gY_G[i][j]*gf[j]+gY_B[i][j]*ge[j];
}
Ps=ge[i]*Sum1+gf[i]*Sum2;
Qs=gf[i]*Sum1-ge[i]*Sum2;
printf("节点%d是平衡节点,其注入有功为%10.5f,注入无功为%10.5f\n",i+1,Ps,Qs);
}
if(gBus[i].Type==2)
{
for(j=0;j<=Bus_Num-1;j++)
{
Qv+=gf[i]*(gY_G[i][j]*ge[j]-gY_B[i][j]*gf[j])-ge[i]*(gY_G[i][j]*gf[j]+gY_B[i][j]*ge[j]) ;
}
printf("节点%d是PV节点，其注入有功为%10.5f，注入无功为%10.5f\n",i+1,
gBus[i].GenQ-gBus[i].LoadQ,Qv );
}
if(gBus[i].Type==1)
{
printf("节点%d是PQ节点，其注入有功为%10.5f，注入无功为%10.5f\n",i+1,
gBus[i].GenP-gBus[i].LoadP,gBus[i].GenQ-gBus[i].LoadQ );
}
}
}
void Get_Loss_of_Net() //全网络的网损
{
int i,j;
int m,n; //线路首末端编号赋值给m,n
float Delta_P[Line_Num],Delta_Q[Line_Num]; //网损
float Sum_Delta_P=0,Sum_Delta_Q=0; //总网损
float G0[Line_Num],B0[Line_Num],G[Line_Num][Line_Num],B[Line_Num][Line_Num];
float k,r,x,d;
printf("\n\n*****************全网络的网损*****************\n\n");
//赋值
for(i=0;i<=Line_Num-1;i++)
{
Delta_P[i]=0;
Delta_Q[i]=0;
}
for(i=0;i<=Line_Num-1;i++)
{
m=gLine[i].No_I-1;
n=gLine[i].No_J-1;
if(gLine[i].k==0)
{
G0[m]=0;
G0[n]=0;
B0[m]=gLine[i].B;
B0[n]=gLine[i].B;
G[m][n]=-gY_G[m][n];
B[m][n]=-gY_B[m][n];
Delta_P[i]=(ge[m]*ge[m]+gf[m]*gf[m])*G0[m]+(ge[n]*ge[n]+gf[n]*gf[n])*G0[n]+((ge[m]-ge[n ])*(ge[m]-ge[n])+(gf[m]-gf[n])*(gf[m]-gf[n]));
Delta_Q[i]=-((ge[m]*ge[m]+gf[m]*gf[m])*B0[m]+(ge[n]*ge[n]+gf[n]*gf[n])*B0[n]+((ge[m]-ge [n])*(ge[m]-ge[n])+(gf[m]-gf[n])*(gf[m]-gf[n]))*B[m][n]);
}
if(gLine[i].k!=0)
{
k=gLine[i].k;
r=gLine[i].R;
x=gLine[i].X;
d=r*r+x*x;
G0[m]=(((1-k)/(k*k))*r)/d;
G0[n]=(((k-1)/(k))*r)/d;
B0[m]=(((1-k)/(k*k))*(-x))/d;
B0[n]=(((k-1)/(k))*(-x))/d;
G[m][n]=(1/k)*r/d;
B[m][n]=(1/k)*(-x)/d;
Delta_P[i]=(ge[m]*ge[m]+gf[m]*gf[m])*G0[m]+(ge[n]*ge[n]+gf[n]*gf[n])*G0[n]+((ge[m]-ge[n ])*(ge[m]-ge[n])+(gf[m]-gf[n])*(gf[m]-gf[n]));
Delta_Q[i]=-((ge[m]*ge[m]+gf[m]*gf[m])*B0[m]+(ge[n]*ge[n]+gf[n]*gf[n])*B0[n]+((ge[m]-ge [n])*(ge[m]-ge[n])+(gf[m]-gf[n])*(gf[m]-gf[n]))*B[m][n]);
}
}
for(i=0;i<=Line_Num-1;i++)
{
Sum_Delta_P+=Delta_P[i];
Sum_Delta_Q+=Delta_Q[i];
}
for(i=0;i<=Line_Num-1;i++)
{
printf("线路%d的消耗功率，有功为：%10.5f，无功为：%10.5f\n",gLine[i].No,Delta_P[i], Delta_Q[i]);
}
printf("\n全网总网损，有功为：%10.5f，无功为：%10.5f\n\n",Sum_Delta_P,Sum_Delta_Q);
}
int main(int argc, char* argv[])
{
int i,Count_Num;
float maxValue;
test();
GetData();
GetYMatrix();
SetInitial();
for(Count_Num=0;Count_Num<=2;Count_Num++)
{
GetUnbalance();
GetJaccobi();
GetRevised();
GetNewValue();
maxValue=fabs(gDelta_fe[0]);
for(i=1;i<=2*(Bus_Num-1)-1;i++)
{
if(maxValue<fabs(gDelta_fe[i]))
{
maxValue=fabs(gDelta_fe[i]);
}
}
if(maxValue<Precision)
{
break;
}
}
printf("\n迭代次数:%d\n\n",Count_Num);
printf("节点电压：\n");
printf(" 实部虚部幅值\n");
for(i=0;i<=Bus_Num-1;i++)
{
printf("U(%d)=%10.5f %10.5f %10.5f\n",i+1,ge[i],gf[i],sqrt(ge[i]*ge[i]+gf[i]*gf[i] ));
}
GetS(); //调用求功率的子函数
Get_Loss_of_Net(); //调用求网损的子函数
return 0;
}
（注：对于3节点，将config.h头文件中，#define Bus_Num 值设为3，#define Line_Num 值设为2，#define Precision 值设为1e-3,即可。

）。