电力系统分析潮流实验报告

时间：2024.4.2

南昌大学实验报告

学生姓名：学号：专业班级：

实验类型：□ 验证 □ 综合 ■ 设计 □ 创新实验日期：实验成绩：

电力系统潮流计算实验

一、实验目的：

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

二、实验内容：

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

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

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

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

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

%数据输入

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);

四、例题及运行结果

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

系统中节点1、2为PQ节点，节点3为PV节点，节点4为平衡节点，已给定

P_1s+jQ_1s=-0.30-j0.18 P_2s+jQ_2s=-0.55-j0.13 P_3s=0.5 V_3s=1.10 V_4s=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");

}

更多相关推荐：

电力系统自动化实验报告: 学院专业班级学号姓名指导老师完成时间电力系统自动化报告核技术与自动化学院电气工程及其自动化20xx060505班320xx06050504顾民20xx年4月30日电力系统自动化实验报告实验一发电机组的启动与运转...
电力系统实验报告: 电力系统实验报告班级学号姓名实验一同步发电机准同期并列实验一实验目的1加深理解同步发电机准同期并列原理掌握准同期并列条件2掌握微机准同期控制器及模拟式综合整步表的使用方法3熟悉同步发电机准同期并列过程4观察分析...
电力系统实验报告: 单机无穷大系统稳态实验一整理实验数据说明单回路送电和双回路送电对电力系统稳定运行的影响并对实验结果进行理论分析实验数据如下由实验数据我们得到如下变化规律1保证励磁不变的情况下同一回路随着有功输出的增加回路上电流...
电力系统实验报告: 重庆邮电大学移通学院自动化系电力系统自动化及其微机保护实验专业电气工程及其自动化班级05111001学号0511100104姓名刘欣琪重庆邮电大学移通学院自动化系制20xx年12日实验一DL31型电流继电器特性...
电力系统分析实验报告: 电力系统分析实验报告实验项目1单机无穷大系统稳态运行实验2电力系统暂态稳定实验学院电气信息学院专业电气工程及其自动化班级20xx级学号姓名单机无穷大系统稳态运行实验一实验目的1了解和掌握对称稳定情况下输电系统的...
电力系统分析课程设计报告: 电力系统分析课程设计专业电气工程及其自动化设计题目电力系统分析课程设计班级电自1042学生姓名杨鹏学号指导教师王彬分院院长许建平教研室主任高纯斌电气工程学院一课程设计任务书1课程题目电力系统课程设计2设计内容双...
电力系统分析实验报告: 五邑大学电力系统分析理论实验报告院系专业学号学生姓名指导教师实验一仿真软件的初步认识一、实验目的：通过使用PowerWorld电力系统仿真软件，掌握电力系统的结构组成，了解电力系统的主要参数，并且学会了建立一个…

电力系统暂态上机计算课程设计报告附程序: 课程设计报告20xx20xx年度第二学期名称电力系统暂态上机院系电气与电子工程学院班学号1091420xx8学生姓名雷刚指导教师麻秀范老师设计周数成绩日期20xx年7月3日课程电力系统暂态上机课程设计报告一课程...
电力系统自动化实验报告: 电力系统自动化实验报告实验一发电机组的启动与运转实验一实验目的123了解微机调速装置的工作原理和掌握其操作方法熟悉发电机组中原动机直流电动机的基本特性掌握发电机组起励建压并网解列和停机的操作二原理说明在本实验平...
电力系统实验报告: 电力系统实验报告学院核技术与自动化工程学院专业电气工程及其自动化指导老师顾珉姓名许学号新20xx06050209实验一发电机组的启动与运转实验一实验目的1了解微机调速装置的工作原理和掌握其操作方法2熟悉发电机组...
电力系统实验报告: 电力系统实验报告实验项目用PowerWorld建立一个简单的电力系统模型专业班级学号姓名实验日期一实验目的掌握电力系统的结构组成了解电力系统的主要参数熟悉PowerWorld电力系统仿真软件简称PWS的基本操作...

南昌大学电力系统分析实验报告1: 南昌大学实验报告学生姓名李开卷学号6100312199专业班级电力系统124班实验类型验证综合设计创新实验日期1128实验成绩一实验项目名称电力网数学模型模拟实验二实验目的与要求本实验通过对电力网数学模型形成的...

热门关注