C语言编写短路电流计算的程序.docx
《C语言编写短路电流计算的程序.docx》由会员分享，可在线阅读，更多相关《C语言编写短路电流计算的程序.docx（12页珍藏版）》请在冰点文库上搜索。
C语言编写短路电流计算的程序
初始条件：
如图所示电力系统，最大运行方式时，两个电源同时送电，变压器并联运行，忽略线路电阻，线路电抗0.4Ω/km。
计算k1和k2点在最大运行方式时的三相短路电流。
要求完成的主要任务:
（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）
1.写出三相短路电流的计算方法；
2.用C或FORTRAN语言实现三相短路电流的计算程序；
3.调试程序并求出计算结果；
4.撰写计算方法原理、计算流程文档及设计说明书；
5.提供计算程序代码。
代码使用C++编写的，共有三个文件，请建立工程，一起编译。
这是Plural.hpp
#ifndefPLURAL_HPP
#definePLURAL_HPP
//类名称：
Plural
//方法：
GetR,GetI,SetRI,SetR,SetI
//数据：
m_pluralR,m_pluralI
classPlural
{
public:
Plural（）;
Plural（floatpR,floatpI）;
~Plural（）;
floatGetR（）const;
floatGetI（）const;
voidSetRI（floatpR,floatpI）;
voidSetR（floatpR）;
voidSetI（floatpI）;
private:
floatm_pluralR;
floatm_pluralI;
};
//名称:
复数乘法，PluralMul（Pluralplural1,Pluralplural2）
//参数：
复数plural1plural2
//返回值：
复数
PluralPluralMul（Pluralplural1,Pluralplural2）;
//函数名：
复数除法，运算浮点数除以复数
//参数：
num，分子，是一个浮点数。
den，分母，是一个复数
//返回值：
结果的复数
PluralPluralDiv（floatnum,Pluralden）;
//函数名：
复数求倒数
//参数：
den，分母，是一个复数
//返回值：
此复数的倒数
PluralPluralDiv（Pluralplu）;
//参数：
mat为待变换的复数矩阵的数组名，n为阶数
//返回值：
无
//说明：
变换后的结果依旧保存在mat中
voidMatrixInv（Plural*mat,intn）;
#endif
#include"plural.hpp"
#include
#include
#include
//类名称：
Plural
//方法：
GetR,GetI,SetRI,SetR,SetI
//数据：
m_pluralR,m_pluralI
Plural:
:
Plural（）
{
m_pluralR=0;
m_pluralI=0;
}
Plural:
:
Plural（floatpR,floatpI）
{
m_pluralR=pR;
m_pluralI=pI;
}
Plural:
:
~Plural（）{}
floatPlural:
:
GetR（）const
{
returnm_pluralR;
}
floatPlural:
:
GetI（）const
{
returnm_pluralI;
}
voidPlural:
:
SetRI（floatpR,floatpI）
{
m_pluralR=pR;
m_pluralI=pI;
}
voidPlural:
:
SetR（floatpR）
{
m_pluralR=pR;
}
voidPlural:
:
SetI（floatpI）
{
m_pluralI=pI;
}
// 名称:
复数乘法，PluralMul（Pluralplural1,Pluralplural2）
// 参数：
复数plural1plural2
// 返回值：
复数
PluralPluralMul（Pluralplural1,Pluralplural2）
{
Pluralresult;
result.SetRI（plural1.GetR（）*plural2.GetR（）-plural1.GetI（）*plural2.GetI（）,plural1.GetR（）*plural2.GetI（）+plural1.GetI（）*plural2.GetR（））;
returnresult;
}
//函数名：
复数除法，运算浮点数除以复数
//参数：
num，分子，是一个浮点数。
den，分母，是一个复数
//返回值：
结果的复数
PluralPluralDiv（floatnum,Pluralden）
{
Pluralresult;
floatk;
k=den.GetR（）*den.GetR（）+den.GetI（）*den.GetI（）;
result.SetR（num*den.GetR（）/k）;
result.SetI（-1.0*num*den.GetI（）/k）;
returnresult;
}
//函数名：
复数求倒数
//参数：
den，分母，是一个复数
//返回值：
此复数的倒数
PluralPluralDiv（Pluralplu）
{
Pluralresult;
floatk;
k=plu.GetR（）*plu.GetR（）+plu.GetI（）*plu.GetI（）;
result.SetR（plu.GetR（）/k）;
result.SetI（-1.0*plu.GetI（）/k）;
returnresult;
}
//说明：
以下3个函数组合用来求复数矩阵的逆。
double*inv（double*A,double*Ainv,intn）;
voidmulAB（double*A,double*B,double*C,intam,intan,intbm,intbn）;
//参数：
mat为待变换的复数矩阵的数组名，n为阶数
//返回值：
无
//说明：
变换后的结果依旧保存在mat中
voidMatrixInv（Plural*mat,intn）;
//矩阵求逆。
A为原矩阵，Ainv为求逆之后矩阵，n为阶数
double*inv（double*A,double*Ainv,intn）
{
int*is,*js,i,j,k,l,u,v;
doubled,p;
for（i=0;i *（Ainv+i）=*（A+i）;
is=（int*）malloc（n*sizeof（int））;
js=（int*）malloc（n*sizeof（int））;
for（k=0;k<=n-1;k++）
{
d=0.0;
for（i=k;i<=n-1;i++）
for（j=k;j<=n-1;j++）
{
l=i*n+j;
p=fabs（Ainv[l]）;
if（p>d）
{
d=p;
is[k]=i;
js[k]=j;
}
}
if（d+1.0==1.0）
{
free（is）;
free（js）;
returnNULL;
}
if（is[k]!
=k）
for（j=0;j<=n-1;j++）
{
u=k*n+j;
v=is[k]*n+j;
p=Ainv[u];
Ainv[u]=Ainv[v];
Ainv[v]=p;
}
if（js[k]!
=k）
for（i=0;i<=n-1;i++）
{
u=i*n+k;
v=i*n+js[k];
p=Ainv[u];
Ainv[u]=Ainv[v];
Ainv[v]=p;
}
l=k*n+k;
Ainv[l]=1.0/Ainv[l];
for（j=0;j<=n-1;j++）
if（j!
=k）
{
u=k*n+j;
Ainv[u]=Ainv[u]*Ainv[l];
}
for（i=0;i<=n-1;i++）
if（i!
=k）
for（j=0;j<=n-1;j++）
if（j!
=k）
{
u=i*n+j;
Ainv[u]=Ainv[u]-Ainv[i*n+k]*Ainv[k*n+j];
}
for（i=0;i<=n-1;i++）
if（i!
=k）
{
u=i*n+k;
Ainv[u]=-Ainv[u]*Ainv[l];}
}
for（k=n-1;k>=0;k--）
{
if（js[k]!
=k）
for（j=0;j<=n-1;j++）
{
u=k*n+j;
v=js[k]*n+j;
p=Ainv[u];
Ainv[u]=Ainv[v];
Ainv[v]=p;
}
if（is[k]!
=k）
for（i=0;i<=n-1;i++）
{
u=i*n+k;
v=i*n+is[k];
p=Ainv[u];
Ainv[u]=Ainv[v];
Ainv[v]=p;
}
}
free（is）;
free（js）;
returnAinv;
}
//参数：
a为原矩阵，b为逆矩阵，c为结果。
其他在此都为n
voidmulAB（double*a,double*b,double*c,intam,intan,intbm,intbn）
{
inti,j,l,u;
if（an!
=bm）
{
printf（"不能完成原矩阵和其逆矩阵矩阵相乘\n"）;
return;
}
for（i=0;i for（j=0;j {
u=i*bn+j;
c[u]=0.0;
for（l=0;l c[u]=c[u]+a[i*an+l]*b[l*bn+j];
}
return;
}
//复数矩阵求逆。
参数：
mat为待求矩阵，n为阶数
voidMatrixInv（Plural*mat,intn）
{
inti,j;
doublepluralR[n][n],pluralI[n][n];
double*a=NULL,*b=NULL,*c=NULL;
double*resultR=NULL,*resultI=NULL;
Pluralresult[n][n];
for（i=0;i {
for（j=0;j {
pluralR[i][j]=mat[i*n+j].GetR（）;
pluralI[i][j]=mat[i*n+j].GetI（）;
}
}
printf（"原始矩阵为:
\n"）;
for（i=0;i {
for（j=0;j printf（"%10.4f+j%0.4f\t",（*pluralR）[i*n+j],（*pluralI）[i*n+j]）;
printf（"\n"）;
}
a=（double*）malloc（n*n*sizeof（double））;
b=（double*）malloc（n*n*sizeof（double））;
c=（double*）malloc（n*n*sizeof（double））;
resultR=inv（*pluralR,a,n）;
resultI=inv（*pluralI,b,n）;
if（resultI!
=NULL）
{
printf（"\n求逆之后虚部是:
\n"）;
if（n%2==0）
{
for（i=0;i {
for（j=0;j printf（"%10.4f+j%0.4f\t",resultR==NULL?
0:
resultR[i*n+j],resultI==NULL?
0:
resultI[i*n+j]）;
printf（"\n"）;
}
}
else
{
for（i=0;i {
for（j=0;j printf（"%10.4f+j%0.4f\t",resultR==NULL?
0:
resultR[i*n+j],resultI==NULL?
0:
-1.0*resultI[i*n+j]）;
printf（"\n"）;
}
}
// 测试所求实部逆矩阵
// mulAB（*pluralR,a,c,n,n,n,n）;
// printf（"\n\n求逆后原实部和现在的实部乘积是\n"）;
// for（i=0;i// {
// for（j=0;j// printf（"%10.4f\t",c[i*n+j]）;
// printf（"\n"）;
// }
// 测试用所求逆矩阵
// mulAB（*pluralI,b,c,n,n,n,n）;
// printf（"\n\n求逆之后原虚部和现在的虚部乘积是:
\n"）;
// for（i=0;i// {
// for（j=0;j// printf（"%10.4f\t",-1.0*c[i*n+j]）;
// printf（"\n"）;
// }
}
for（i=0;i {
for（j=0;j mat[i*n+j].SetRI（resultR==NULL?
0:
resultR[i*n+j],resultI==NULL?
0:
resultI[i*n+j]）;
}
free（a）;
free（b）;
free（c）;
}
#include
#include"plural.hpp"
//#include"input.hpp"
usingnamespacestd;
voidNodInit（）
{
floatg1S,g1X,g2S,g2X,l1L,l1D,l2L,l2D,t1S,t1U,t2S,t2U;
cout<<"请输入发电机G1的容量S（无穷大请输入0）：
";
cin>>g1S;
cout<<"请输入发电机G1的电抗Xd（没有请输入0）：
";
cin>>g1X;
cout<
cout<<"请输入发电机G2的容量S（无穷大请输入0）：
";
cin>>g2S;
cout<<"请输入发电机G2的电抗Xd（没有请输入0）：
";
cin>>g2X;
cout<
cout<<"请输入线路1的长度L（KM）：
";
cin>>l1L;
cout<<"请输入线路1每千米电抗值：
";
cin>>l1D;
cout<
cout<<"请输入线路2的长度L（KM）：
";
cin>>l2L;
cout<<"请输入线路2每千米电抗值：
";
cin>>l2D;
cout<
cout<<"请输入变压器T1的容量S（MVA）：
";
cin>>t1S;
cout<<"请输入变压器T1的Uk%：
";
cin>>t1U;
cout<
cout<<"请输入变压器T2的容量S（MVA）：
";
cin>>t2S;
cout<<"请输入变压器T2的Uk%：
";
cin>>t2U;
}
intmain（）
{
NodInit（）;
Pluralmatrix2[3][3];
matrix2[0][0].SetRI（0,1）;matrix2[0][1].SetRI（0,2）;matrix2[1][0].SetRI（0,1）;matrix2[1][1].SetRI（0,1）;
matrix2[0][2].SetRI（0,2）;matrix2[1][2].SetRI（0,1）;matrix2[2][0].SetRI（0,3）;matrix2[2][1].SetRI（0,2）;matrix2[2][2].SetRI（0,1）;
MatrixInv（*matrix2,3）;
printf（"\n1点短路电流是\n"）;
printf（"%f+j%f",PluralDiv（matrix2[0][0]）.GetR（）,PluralDiv（matrix2[0][0]）.GetI（））;
printf（"\n2点短路电流是\n"）;
printf（"%f+j%f",PluralDiv（matrix2[1][1]）.GetR（）,PluralDiv（matrix2[1][1]）.Ge
升级会员 