南昌大学实验报告

电力系统潮流计算实验 学生姓名： 学 号： 专业班级： 实验类型：□ 验证 □ 综合 ■ 设计 □ 创新 实验日期： 实验成绩：

一、实验目的：

本实验通过对电力系统潮流计算的计算机程序的编制与调试，获得对复杂电力系统进行潮流计算的计算机程序，使系统潮流计算能够由计算机自行完成，即根据已知的电力网的数学模型（节点导纳矩阵）及各节点参数，由计算程序运行完成该电力系统的潮流计算。通过实验教学加深学生对复杂电力系统潮流计算计算方法的理解，学会运用电力系统的数学模型，掌握潮流计算的过程及其特点，熟悉各种常用应用软件，熟悉硬件设备的使用方法，加强编制调试计算机程序的能力，提高工程计算的能力，学习如何将理论知识和实际工程问题结合起来。

二、实验内容：

编制调试电力系统潮流计算的计算机程序。程序要求根据已知的电力网的数学模型（节点导纳矩阵）及各节点参数，完成该电力系统的潮流计算，要求计算出节点电压、功率等参数。

1、 在各种潮流计算的算法中选择一种，按照计算方法编制程序。

2、 将事先编制好的电力系统潮流计算的计算程序原代码由自备移动存储设备导入计算机。

3、 在相应的编程环境下对程序进行组织调试。

4、 应用计算例题验证程序的计算效果。

三、实验程序：

function [e,f,p,q]=flow_out(g,b,kind,e,f)

%计算潮流后efpq的终值

s=flow(g,b,kind,e,f);

k=0;

while max(abs(s))>10^-5

J=J_out(g,b,kind,e,f);

J_ni=inv(J);

dv=J_ni*s;

l=length(dv)/2;

for i=1:l

e(i)=e(i)-dv(2*i-1);

f(i)=f(i)-dv(2*i);

end

s=flow(g,b,kind,e,f);

end

l=length(e);

for i=1:l

s1=0;

s2=0;

for j=1:l

s1=s1+g(i,j)*e(j)-b(i,j)*f(j); s2=s2+g(i,j)*f(j)+b(i,j)*e(j); end

p(i)=e(i)*s1+f(i)*s2;

q(i)=f(i)*s1-e(i)*s2;

end

function s=flow(g,b,kind,e,f)

%计算当前ef与规定的pqv的差值

l=length(e);

s=zeros(2*l-2,1);

for i=1:(l-1)

s1=0;

s2=0;

for j=1:l

s1=s1+g(i,j)*e(j)-b(i,j)*f(j); s2=s2+g(i,j)*f(j)+b(i,j)*e(j); end

s(2*i-1)=kind(2,i)-e(i)*s1-f(i)*s2; if kind(1,i)==1

s(2*i)=kind(3,i)-f(i)*s1+e(i)*s2; else

s(2*i)=kind(3,i)^2-f(i)^2-e(i)^2; end

end

function J=J_out(g,b,kind,e,f)

%计算节点的雅克比矩阵

l=length(e);

J=zeros(2*l-2,2*l-2);

for i=1:(l-1);

if kind(1,i)==1

s=PQ_out(g,b,e,f,i);

for j=1:(2*l-2)

J(2*i-1,j)=s(1,j);

J(2*i,j)=s(2,j);

end

else

s=PV_out(g,b,e,f,i);

for j=1:(2*l-2)

J(2*i-1,j)=s(1,j);

J(2*i,j)=s(2,j);

end

end

end

function pq=PQ_out(g,b,e,f,i)

%计算pq节点的雅克比矩阵

l=length(e);

pq=zeros(2,2*l-2);

for j=1:(l-1)

if j==i

s=0;

for k=1:l

s=s-(g(i,k)*e(k)-b(i,k)*f(k)); end

pq(1,2*i-1)=s-g(i,i)*e(i)-b(i,i)*f(i); s=0;

for k=1:l

s=s-(g(i,k)*f(k)+b(i,k)*e(k)); end

pq(1,2*i)=s+b(i,i)*e(i)-g(i,i)*f(i); s=0;

for k=1:l

s=s+(g(i,k)*f(k)+b(i,k)*e(k)); end

pq(2,2*i-1)=s+b(i,i)*e(i)-g(i,i)*f(i); s=0;

for k=1:l

s=s-(g(i,k)*e(k)-b(i,k)*f(k)); end

pq(2,2*i)=s+g(i,i)*e(i)+b(i,i)*f(i); else

pq(1,2*j-1)=-(g(i,j)*e(i)+b(i,j)*f(i)); pq(1,2*j)=b(i,j)*e(i)-g(i,j)*f(i); pq(2,2*j)=-pq(1,2*j-1);

pq(2,2*j-1)=pq(1,2*j);

end

end

function pv=PV_out(g,b,e,f,i)

%计算pv节点的雅克比矩阵

l=length(e);

pv=zeros(2,2*l-2);

for j=1:(l-1)

if j==i

s=0;

for k=1:l

s=s-(g(i,k)*e(k)-b(i,k)*f(k)); end

pv(1,2*i-1)=s-g(i,i)*e(i)-b(i,i)*f(i); s=0;

for k=1:l

s=s-(g(i,k)*f(k)+b(i,k)*e(k)); end

pv(1,2*i)=s+b(i,i)*e(i)-g(i,i)*f(i); pv(2,2*i-1)=-2*e(i);

pv(2,2*i)=-2*f(i);

else

pv(1,2*j-1)=-(g(i,j)*e(i)+b(i,j)*f(i)); pv(1,2*j)=b(i,j)*e(i)-g(i,j)*f(i); end

end

%数据输入

g=[1.042093 -0.588235 0 -0.453858

-0.588235 1.069005 0 -0.480769

0 0 0 0

-0.453858 -0.480769 0 0.9344627];

b=[-8.242876 2.352941 3.666667 1.891074

2.352941 -4.727377 0 2.403846

3.666667 0 -3.333333 0

1.891074 2.40385 0 4.26159];

e=[1 1 1.1 1.05];

f=[0 0 0 0];

kind=[1 1 2 0

-0.3 -0.55 0.5 1.05

-0.18 -0.13 1.1 0];

[e,f,p,q]=flow_out(g,b,kind,e,f);

e

f

四、例题及运行结果

在上图所示的简单电力系统中，

系统中节点1、2为PQ节点，节点3为PV节点，节点4为平衡节点，已给定 P1s+jQ1s=-0.30-j0.18 P2s+jQ2s=-0.55-j0.13 P3s=0.5 V3s=1.10 V4s=1.05∠0° 容许误差ε=10-5

节点导纳矩阵：

各节点电压：

节点 e f v ζ

1. 0.984637 -0.008596 0.984675 -0.500172

2. 0.958690 -0.108387 0.964798 -6.450306

3. 1.092415 0.128955 1.100000 6.732347

4. 1.050000 0.000000 1.050000 0.000000

各节点功率：

节点 P Q

1 -0.300000 -0.180000

2 –0.550000 -0.130000

3 0.500000 -0.551305

4 0.367883 0.264698

结果：

五、思考讨论题

1.潮流计算有几种方法？简述各种算法的优缺点。

答：高斯迭代法（高斯塞德尔法），牛顿拉夫逊法以及P-Q分解法。高斯迭代法是直接迭代，对初值要求比较低，程序简单，内存小，但收敛性差，速度慢，多用于配电网或辐射式网络中；牛顿拉夫逊法是将非线性方程线性化之后再迭代的，对初值要求比较高，收敛性好，速度快，迭代次数少，运行时间短，被广泛使用；P-Q分解法是在极坐标牛顿法的基础上进行三个简化所得，有功、无功分开迭代，迭代次数比牛顿多一倍但运算量小，整体速度更快，运行时间更短，多用于110KV以上的高压电网中

2.在潮流计算中，电力网络的节点分几类？各类节点的已知量和待求量是什么？

答: PQ节点：P、Q为已知量，V、?为待求量；PV节点：给定P、V，求Q、?；平衡节点：给定V、?，求P、Q。

3.潮流计算中的雅可比矩阵在每次迭代时是一样的吗？为什么？

答:不一样,因为每次迭代的电压、有功、无功都是与前一次不同的新值，所以每次迭代过程中，雅可比矩阵都是变化的。

六、实验心得

这次实验是通过matlab编写出一个潮流计算的程序。我这用了牛顿法直角坐标系来编写程序的。通过编写这次程序可以更深一步的理解潮流计算的步骤，也明白了在潮流计算中要注意的一些细节。

 

第二篇：电力系统分析潮流计算程序

#include<stdio.h>

#include<stdlib.h>

#include<math.h>

#define PI 3.14159

//节点参数结构体

structNodeType

{

int N;//节点号

int Type;//节点类型

double e;//电压幅值

double f;//电压相角

double Pd;//负荷有功

double Qd;//负荷无功

double Ps;//出力有功

double Qs;//出力无功

double Bc;//并联电容的电抗值

};

//支路参数结构体

structBranchType

{

intNbr;//支路号

intNl;//首节点

int Nr;//末节点

double R;//支路电阻

double X;//支路电抗

double Bn;//对地电抗

double Kt;//支路变比

};

//********************************************************************************* int n;//节点数

intnPQ;//PQ节点数

intnPV;//PV节点数

intnbr;//支路数

intng;//发电机台数

int Mark=0;//标记支路参数是否已经转换

double **G;//导纳矩阵G部分

double **B;//导纳矩阵B部分

全局变量声明

double *dS;//功率不平衡量

double *mid1,*mid2;//求功率不平衡量时的中间变量

double *Us;//电压初值

double error=1;//误差值

double iteration=0.000001;//误差精度

double **Jacob;//雅克比矩阵

double **invJac;//雅克比矩阵的逆

double *dfe;//节点电压修正值

structNodeType *Node;//读入时的节点参数结构体 structBranchType *Branch;//读入时的支路参数结构体

//*************************************************************************************** void main()

{

voidLoadData();

void FormY();//形成导纳矩阵

void DeltaS();//求功率不平衡量

void FormJacob();//形成雅克比矩阵

void InvJac();//求雅克比矩阵的逆

void UpdateU();//修正电压值

voidCalculatePQ();

void Print1(double *,int);

void Print2(double **,int,int);

intkk;//迭代次数

LoadData();

FormY();

printf("iteration=%lf\n",iteration);

kk=0;

DeltaS();

while(error>iteration&&kk<50)

{

FormJacob(); 主程序

UpdateU();

DeltaS();

kk++;

}

printf("迭代次数为%4d\n",kk);

CalculatePQ();

printf("error=%e\n",error);

}

//*********************************************************************************************

voidLoadData()

{

inti,j;

inttN,tType;

double te,tf,tPd,tQd,tPs,tQs,tBc;//用于重新排列节点信息的临时变量

FILE *fp;//文件指针

char filename[50]={""};

printf("请输入数据文件名：");

scanf("%s",filename);

if((fp=fopen(filename,"r"))==NULL)

{

printf("cannot open the file:data.txt\n");

return;

}

fscanf(fp,"%d",&n);

printf("节点个数为：%d\n",n);

//为节点参数申请空间

Node=(structNodeType *)malloc(sizeof(structNodeType)*n);

//读取节点参数

printf("调整前的节点参数为：\n");

for(i=0;i<n;i++)

fscanf(fp,"%d%d%lf%lf%lf%lf%lf%lf%lf",&Node[i].N,&Node[i].Type,&Node[i].e,&Node[i].f,&Node[i].Pd,&Node[i].Qd,&Node[i].Ps,&Node[i].Qs,&Node[i].Bc);

//计算PQ节点和PV节点的个数

for(i=0;i<n;i++)

{

if(Node[i].Type==1)

nPQ++;

else if(Node[i].Type==2)

nPV++;

}

printf("PQ节点个数：%d\n",nPQ);

printf("PV节点个数：%d\n",nPV);

//重新排列节点参数(冒泡法)

for(j=0;j<n-1;j++)

for(i=0;i<n-j-1;i++)

{

if(Node[i].Type>Node[i+1].Type)

{

tN=Node[i].N;Node[i].N=Node[i+1].N;Node[i+1].N=tN;

tType=Node[i].Type;Node[i].Type=Node[i+1].Type;Node[i+1].Type=tType;

te=Node[i].e;Node[i].e=Node[i+1].e;Node[i+1].e=te;

tf=Node[i].f;Node[i].f=Node[i+1].f;Node[i+1].f=tf;

tPd=Node[i].Pd;Node[i].Pd=Node[i+1].Pd;Node[i+1].Pd=tPd;

tQd=Node[i].Qd;Node[i].Qd=Node[i+1].Qd;Node[i+1].Qd=tQd;

tPs=Node[i].Ps;Node[i].Ps=Node[i+1].Ps,Node[i+1].Ps=tPs;

tQs=Node[i].Qs;Node[i].Qs=Node[i+1].Qs;Node[i+1].Qs=tQs;

tBc=Node[i].Bc;Node[i].Bc=Node[i+1].Bc;Node[i+1].Bc=tBc;

}

}

//为电压初值申请空间

Us=(double *)malloc(sizeof(double)*(n-1));

for(i=0;i<n-1;i++)

Us[i]=Node[i].e;

//读取支路参数

fscanf(fp,"%d",&nbr);

printf("支路个数为：%d\n",nbr);

//为支路参数申请空间

Branch=(structBranchType *)malloc(sizeof(structBranchType)*nbr);//读入的支路参数结构体

//读入支路参数

for(i=0;i<nbr;i++)

fscanf(fp,"%d%d%d%lf%lf%lf%lf",&Branch[i].Nbr,&Branch[i].Nl,&Branch[i].Nr,&Branch[i].R,&Branch[i].X,&Branch[i].Bn,&Branch[i].Kt);

//支路节点号参数调整

for(i=0;i<nbr;i++)

{

Mark=0;

for(j=0;j<n;j++)

{

if(Branch[i].Nl==Node[j].N&&Mark==0)

{

Branch[i].Nl=j+1;

Mark=1;

}

}

}

for(i=0;i<nbr;i++)

{

Mark=0;

for(j=0;j<n;j++)

{

if(Branch[i].Nr==Node[j].N&&Mark==0)

{

Branch[i].Nr=j+1;

Mark=1;

}

}

}

fclose(fp);

}

//***********************************************************************************************************************

//*********************************************形成导纳矩阵**************************************************************

voidFormY()

{

inti,j;

double Z2;//存储Z^2=R^2+X^2

G=(double **)malloc(sizeof(double *)*n);//为G申请空间

B=(double **)malloc(sizeof(double *)*n);//为B申请空间

for(i=0;i<n;i++)

{

G[i]=(double *)malloc(sizeof(double)*n);

B[i]=(double *)malloc(sizeof(double)*n);

}

//初始化G、B

for(i=0;i<n;i++)

for(j=0;j<n;j++)

{

G[i][j]=0;

B[i][j]=0;

}

//计算非对角元素

for(i=0;i<nbr;i++)

{

Z2=Branch[i].R*Branch[i].R+Branch[i].X*Branch[i].X;

if(Branch[i].Kt==0)//非变压器支路

{

G[Branch[i].Nl-1][Branch[i].Nr-1]-=Branch[i].R/Z2;

B[Branch[i].Nl-1][Branch[i].Nr-1]+=Branch[i].X/Z2;

G[Branch[i].Nr-1][Branch[i].Nl-1]=G[Branch[i].Nl-1][Branch[i].Nr-1];

B[Branch[i].Nr-1][Branch[i].Nl-1]=B[Branch[i].Nl-1][Branch[i].Nr-1];

}

else//变压器支路

{

G[Branch[i].Nl-1][Branch[i].Nr-1]-=Branch[i].R/Z2/Branch[i].Kt;

B[Branch[i].Nl-1][Branch[i].Nr-1]+=Branch[i].X/Z2/Branch[i].Kt;

G[Branch[i].Nr-1][Branch[i].Nl-1]=G[Branch[i].Nl-1][Branch[i].Nr-1];

B[Branch[i].Nr-1][Branch[i].Nl-1]=B[Branch[i].Nl-1][Branch[i].Nr-1];

}

}

//计算对角元素

for(i=0;i<n;i++)

for(j=0;j<nbr;j++)

{

Z2=Branch[j].R*Branch[j].R+Branch[j].X*Branch[j].X;

if(Branch[j].Kt==0&&(Branch[j].Nl-1==i||Branch[j].Nr-1==i))//非变压器支路 {

G[i][i]=G[i][i]+Branch[j].R/Z2;

B[i][i]=B[i][i]-Branch[j].X/Z2;

}

else if(Branch[j].Kt!=0&&(Branch[j].Nl-1==i||Branch[j].Nr-1==i))//变压器支路

{

G[i][i]=G[i][i]+Branch[j].R/Z2/Branch[j].Kt;

B[i][i]=B[i][i]-Branch[j].X/Z2/Branch[j].Kt;

}

}

//将对地电纳加入到对角元素中

for(i=0;i<nbr;i++)

{

if(Branch[i].Kt==0)//非变压器支路

{

B[Branch[i].Nl-1][Branch[i].Nl-1]+=Branch[i].Bn;

B[Branch[i].Nr-1][Branch[i].Nr-1]+=Branch[i].Bn;

}

else//变压器支路

{

B[Branch[i].Nl-1][Branch[i].Nl-1]-=(1-Branch[i].Kt)/Branch[i].Kt/Branch[i].Kt/Branch[i].X; B[Branch[i].Nr-1][Branch[i].Nr-1]-=(Branch[i].Kt-1)/Branch[i].Kt/Branch[i].X;

}

}

//将并联电容加入到对角元素中

for(i=0;i<n;i++)

B[i][i]=B[i][i]+Node[i].Bc;

}

//*************************************************************************************************

//*****************************************

deltaP,deltaQ*****************************************

void DeltaS()//计算功率不平衡量

{

inti,j;

//为中间变量申请空间

mid1=(double *)malloc(sizeof(double)*n);

mid2=(double *)malloc(sizeof(double)*n);

//为功率不平衡量申请空间

dS=(double *)malloc(sizeof(double)*2*(n-1)); 求

//求功率不平衡量

for(i=0;i<n-1;i++)

{

//初始化中间变量

mid1[i]=0;

mid2[i]=0;

for(j=0;j<n;j++)

{

mid1[i]=mid1[i]+G[i][j]*Node[j].e-B[i][j]*Node[j].f;

mid2[i]=mid2[i]+G[i][j]*Node[j].f+B[i][j]*Node[j].e;

}

dS[2*i]=Node[i].Ps-Node[i].Pd-(Node[i].e*mid1[i]+Node[i].f*mid2[i]);

if(i<nPQ)

dS[2*i+1]=Node[i].Qs-Node[i].Qd-(Node[i].f*mid1[i]-Node[i].e*mid2[i]);

else

dS[2*i+1]=Us[i]*Us[i]-(Node[i].e*Node[i].e+Node[i].f*Node[i].f);

}

error=0;

for(i=0;i<2*(n-1);i++)

{

if(dS[i]<0&&error<-dS[i])

error=-dS[i];

else if(dS[i]>0&&error<dS[i])

error=dS[i];

}

}

//*************************************************************************************************

//*********************************************

******************************************

voidFormJacob()

{

inti,j;

//为雅克比行列式申请空间

Jacob=(double **)malloc(sizeof(double *)*2*(n-1));

for(i=0;i<2*(n-1);i++)

Jacob[i]=(double *)malloc(sizeof(double)*2*(n-1));

//初始化雅克比行列式 雅克比矩阵

for(i=0;i<2*(n-1);i++)

for(j=0;j<2*(n-1);j++)

Jacob[i][j]=0;

for(j=0;j<n-1;j++)

{

//求H,N

for(i=0;i<n-1;i++)

{

if(i!=j)

{

Jacob[2*i][2*j]=B[i][j]*Node[i].e-G[i][j]*Node[i].f;

Jacob[2*i][2*j+1]=-G[i][j]*Node[i].e-B[i][j]*Node[i].f; }

else

{

Jacob[2*i][2*i]=B[i][i]*Node[i].e-G[i][i]*Node[i].f-mid2[i]; Jacob[2*i][2*i+1]=-G[i][i]*Node[i].e-B[i][i]*Node[i].f-mid1[i]; }

}

//求J,L

for(i=0;i<nPQ;i++)

{

if(i!=j)

{

Jacob[2*i+1][2*j]=G[i][j]*Node[i].e+B[i][j]*Node[i].f; Jacob[2*i+1][2*j+1]=B[i][j]*Node[i].e-G[i][j]*Node[i].f; }

else

{

Jacob[2*i+1][2*i]=G[i][i]*Node[i].e+B[i][i]*Node[i].f-mid1[i]; Jacob[2*i+1][2*i+1]=B[i][i]*Node[i].e-G[i][i]*Node[i].f+mid2[i]; }

}

//求R,S

for(i=nPQ;i<n-1;i++)

{

if(i==j)

{

Jacob[2*i+1][2*i]=-2*Node[i].f;

Jacob[2*i+1][2*i+1]=-2*Node[i].e;

}

}

}

}

//*************************************************************************************************

//********************************************

***************************************

voidInvJac()

{

inti,j,k;

double temp;//中间变量

//为雅克比矩阵的逆申请空间

invJac=(double **)malloc(sizeof(double *)*2*(n-1));

for(i=0;i<2*(n-1);i++)

invJac[i]=(double *)malloc(sizeof(double)*2*(n-1));

//求逆

for(i=0;i<2*(n-1);i++)

for(j=0;j<2*(n-1);j++)

{

if(i!=j)

invJac[i][j]=0;

else

invJac[i][j]=1;

}

for(i=0;i<2*(n-1);i++)

{

for(j=0;j<2*(n-1);j++)

{

if(i!=j)

{

temp=Jacob[j][i]/Jacob[i][i];

for(k=0;k<2*(n-1);k++)

{

Jacob[j][k]-=Jacob[i][k]*temp;

invJac[j][k]-=invJac[i][k]*temp;

}

}

}

}

for(i=0;i<2*(n-1);i++)

if(Jacob[i][i]!=1)

{

temp=Jacob[i][i];

for(j=0;j<2*(n-1);j++) 雅克比矩阵求逆

invJac[i][j]=invJac[i][j]/temp;

}

}

//*************************************************************************************************

//*********************************************电

********************************************

voidUpdateU()

{

void InvJac();//求雅克比矩阵的逆

inti,j;

dfe=(double *)malloc(sizeof(double)2*(n-1));

InvJac();

for(i=0;i<2*(n-1);i++)

{

dfe[i]=0;

for(j=0;j<2*(n-1);j++)

dfe[i]-=invJac[i][j]*dS[j];

}

for(i=0;i<n-1;i++)

{

Node[i].e+=dfe[2*i+1];

Node[i].f+=dfe[2*i];

}

}

voidCalculatePQ()

{

inti,j;

inttN,tType;

double te,tf,tPd,tQd,tPs,tQs,tBc;//用于重新排列节点信息的临时变量

//计算平衡节点功率

mid1[n-1]=0;

mid2[n-1]=0;

for(j=0;j<n;j++)

{

mid1[n-1]=mid1[n-1]+G[n-1][j]*Node[j].e-B[n-1][j]*Node[j].f;

mid2[n-1]=mid2[n-1]+G[n-1][j]*Node[j].f+B[n-1][j]*Node[j].e; 压修正

}

Node[n-1].Ps=Node[n-1].e*mid1[n-1];

Node[n-1].Qs=-Node[n-1].e*mid2[n-1];

//计算PV节点的Q

for(i=nPQ;i<n-1;i++)

Node[i].Qs=Node[i].f*mid1[i]-Node[i].e*mid2[i];

//将节点参数排列为按节点号从小到大排列

for(j=0;j<n-1;j++)

for(i=0;i<n-j-1;i++)

{

if(Node[i].N>Node[i+1].N)

{

tN=Node[i].N;Node[i].N=Node[i+1].N;Node[i+1].N=tN;

tType=Node[i].Type;Node[i].Type=Node[i+1].Type;Node[i+1].Type=tType;

te=Node[i].e;Node[i].e=Node[i+1].e;Node[i+1].e=te;

tf=Node[i].f;Node[i].f=Node[i+1].f;Node[i+1].f=tf;

tPd=Node[i].Pd;Node[i].Pd=Node[i+1].Pd;Node[i+1].Pd=tPd;

tQd=Node[i].Qd;Node[i].Qd=Node[i+1].Qd;Node[i+1].Qd=tQd;

tPs=Node[i].Ps;Node[i].Ps=Node[i+1].Ps,Node[i+1].Ps=tPs;

tQs=Node[i].Qs;Node[i].Qs=Node[i+1].Qs;Node[i+1].Qs=tQs;

tBc=Node[i].Bc;Node[i].Bc=Node[i+1].Bc;Node[i+1].Bc=tBc;

}

}

//转换为极坐标形式

for(i=0;i<n;i++)

{

te=sqrt(Node[i].e*Node[i].e+Node[i].f*Node[i].f);

tf=atan(Node[i].f/Node[i].e)*180/PI;

Node[i].e=te;

Node[i].f=tf;

}

//输出结果

printf("最终结果为：\n");

printf(" N Tp Amp DltaPdQd Ps Qs Bc\n");

for(i=0;i<n;i++)

printf("%4d%4d%9.4lf%9.4lf%9.4lf%9.4lf%9.4lf%9.4lf%9.4lf\n",Node[i].N,Node[i].Type,Node[i].e,Node[i].f,Node[i].Pd,Node[i].Qd,Node[i].Ps,Node[i].Qs,Node[i].Bc);

}

//*************************************************************************************************

void Print1(double *Mat,int n)

{

int i;

for(i=0;i<n;i++)

printf("%9.4lf\n",Mat[i]);

printf("\n");

}

void Print2(double **Mat,intm,int n)

{

inti,j;

for(i=0;i<m;i++)

{

for(j=0;j<n;j++)

printf("%9.4lf\t",Mat[i][j]);

printf("\n");

}

printf("\n");

}