您好，欢迎来到化拓教育网。
科技 教育 生活 旅游 时尚 美容 美食 健康 体育 游戏 汽车 家电
搜索
您的当前位置：首页短路电流计算

短路电流计算

来源：化拓教育网


题目:三相短路电流计算

初始条件：

如图所示电力系统，最大运行方式时，两个电源同时送电，变压器并联运行，忽略线路电阻，线路电抗0.4Ω/km。计算k1和k2点在最大运行方式时的三相短路电流。

要求完成的主要任务: （包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）

1.写出三相短路电流的计算方法；

2.用C或FORTRAN语言实现三相短路电流的计算程序；

3.调试程序并求出计算结果；

4.撰写计算方法原理、计算流程文档及设计说明书；

5.提供计算程序代码。

代码使用C++编写的，共有三个文件，请建立工程，一起编译。这是Plural.hpp

#ifndef PLURAL_HPP

#define PLURAL_HPP

//类名称：Plural

//方法：GetR,GetI,SetRI,SetR,SetI

//数据：m_pluralR,m_pluralI

class Plural

{

public:

Plural();

Plural(float pR, float pI);

~Plural();

float GetR() const;

float GetI() const;

void SetRI(float pR, float pI);

void SetR(float pR);

void SetI(float pI);

private:

float m_pluralR;

float m_pluralI;

};

//名称: 复数乘法，PluralMul(Plural plural1, Plural plural2)

//参数：复数plural1 plural2

//返回值：复数

Plural PluralMul(Plural plural1, Plural plural2);

//函数名：复数除法，运算浮点数除以复数

//参数：num，分子，是一个浮点数。den，分母，是一个复数

//返回值：结果的复数

Plural PluralDiv(float num, Plural den);

//函数名：复数求倒数

//参数：den，分母，是一个复数

//返回值：此复数的倒数

Plural PluralDiv(Plural plu);

//参数：mat为待变换的复数矩阵的数组名，n为阶数

//返回值：无

//说明 ：变换后的结果依旧保存在mat中

void MatrixInv(Plural *mat, int n);

#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(float pR, float pI)

{

m_pluralR = pR;

m_pluralI = pI;

}

Plural::~Plural(){}

float Plural::GetR() const

{

return m_pluralR;

}

float Plural::GetI() const

{

return m_pluralI;

}

void Plural::SetRI(float pR, float pI)

{

m_pluralR = pR;

m_pluralI = pI;

}

void Plural::SetR(float pR)

{

m_pluralR = pR;

}

void Plural::SetI(float pI)

{

m_pluralI = pI;

}

// 名称: 复数乘法，PluralMul(Plural plural1, Plural plural2)

// 参数：复数plural1 plural2

// 返回值：复数

Plural PluralMul(Plural plural1, Plural plural2)

{

Plural result;

result.SetRI(plural1.GetR() * plural2.GetR() - plural1.GetI() plural2.GetI(),plural1.GetR() * plural2.GetI() + plural1.GetI() * plural2.GetR());

return result;

}

//函数名：复数除法，运算浮点数除以复数

//参数：num，分子，是一个浮点数。den，分母，是一个复数

//返回值：结果的复数

Plural PluralDiv(float num, Plural den)

{

Plural result;

*

float k;

k = den.GetR() * den.GetR() + den.GetI() * den.GetI();

result.SetR(num*den.GetR()/k);

result.SetI(-1.0*num*den.GetI()/k);

return result;

}

//函数名：复数求倒数

//参数：den，分母，是一个复数

//返回值：此复数的倒数

Plural PluralDiv(Plural plu)

{

Plural result;

float k;

k = plu.GetR() * plu.GetR() + plu.GetI() * plu.GetI();

result.SetR(plu.GetR()/k);

result.SetI(-1.0*plu.GetI()/k);

return result;

}

//说明：以下3个函数组合用来求复数矩阵的逆。

double *inv(double *A,double *Ainv,int n);

void mulAB(double *A,double *B,double *C,int am,int an,int bm,int bn);

//参数：mat为待变换的复数矩阵的数组名，n为阶数

//返回值：无

//说明 ：变换后的结果依旧保存在mat中

void MatrixInv(Plural *mat, int n);

//矩阵求逆。A为原矩阵，Ainv为求逆之后矩阵，n为阶数

double *inv(double *A, double *Ainv, int n)

{

int *is, *js, i, j, k, l, u, v;

double d, 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);

return NULL;

}

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

return Ainv;

}

//参数：a为原矩阵，b为逆矩阵，c为结果。其他在此都为n

void mulAB(double *a, double *b, double *c, int am, int an, int bm, int bn)

{

int i, j, l, u;

if (an != bm)

{

printf(\"不能完成原矩阵和其逆矩阵矩阵相乘\\n\");

return;

}

for (i=0; ifor (j=0; j{

u=i*bn+j;

c[u]=0.0;

for (l=0; lc[u]=c[u]+a[i*an+l]*b[l*bn+j];

}

return;

}

//复数矩阵求逆。参数：mat为待求矩阵，n为阶数

void MatrixInv(Plural *mat,int n)

{

int i, j;

double pluralR[n][n], pluralI[n][n];

double *a = NULL, *b = NULL, *c = NULL;

double *resultR = NULL, *resultI = NULL;

Plural result[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;jprintf(\"%10.4f + j%0.4f\\

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; jprintf(\"%10.4f resultI==NULL ? 0:resultI[i*n+j]);

printf(\"\\n\");

}

}

else

{

j%0.4f\\resultR==NULL? 0:resultR[i*n+j], +

for (i=0; i{

for (j=0; jprintf(\"%10.4f + j%0.4f\\resultR==NULL? 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// {

0:resultR[i*n+j],

// for(j=0;j// printf(\"%10.4f\\

// 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\\

// printf(\"\\n\");

// }

}

for (i=0; i{

for (j=0; jmat[i*n+j].SetRI(resultR 0:resultI[i*n+j]);

}

free(a);

free(b);

free(c);

}

#include

#include \"plural.hpp\"

//#include \"input.hpp\"

NULL ? 0:resultR[i*n+j], resultI NULL ? == ==

using namespace std;

void NodInit()

{

float g1S, g1X, g2S, g2X, l1L, l1D, l2L, l2D, t1S, t1U, t2S, t2U;

cout << \"请输入发电机G1的容量S（无穷大请输入0）：\";

cin >> g1S;

cout << \"请输入发电机G1的电抗Xd（没有请输入0）：\";

cin >> g1X;

cout << endl << \"******************************************\" << endl << endl;

cout << \"请输入发电机G2的容量S（无穷大请输入0）：\";

cin >> g2S;

cout << \"请输入发电机G2的电抗Xd（没有请输入0）：\";

cin >> g2X;

cout << endl << \"******************************************\" << endl << endl;

cout << \"请输入线路1的长度L(KM)：\";

cin >> l1L;

cout << \"请输入线路1每千米电抗值：\";

cin >> l1D;

cout << endl << \"******************************************\" << endl << endl;

cout << \"请输入线路2的长度L(KM)：\";

cin >> l2L;

cout << \"请输入线路2每千米电抗值：\";

cin >> l2D;

cout << endl << \"******************************************\" << endl << endl;

cout << \"请输入变压器T1的容量S（MVA）：\";

cin >> t1S;

cout << \"请输入变压器T1的Uk%：\";

cin >> t1U;

cout << endl << \"******************************************\" << endl << endl;

cout << \"请输入变压器T2的容量S（MVA）：\";

cin >> t2S;

cout << \"请输入变压器T2的Uk%：\";

cin >> t2U;

}

int main()

{

NodInit();

Plural matrix2[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 + PluralDiv(matrix2[0][0]).GetI());

printf(\"\\n2点短路电流是\\n\");

printf(\"%f + PluralDiv(matrix2[1][1]).GetI());

printf(\"\\n3点短路电流是\\n\");

printf(\"%f + PluralDiv(matrix2[1][1]).GetI());

getchar();

return 0;

}

j%f\

j%f\

j%f\

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文

Copyright © 2019- huatuo9.cn 版权所有 赣ICP备2023008801号-1

违法及侵权请联系：TEL:199 18 7713 E-MAIL:2724546146@qq.com

本站由北京市万商天勤律师事务所王兴未律师提供法律服务