duanlujisuan.cpp

基于VisualC++的短路计算程序

//短路电流计算程序
//（1）读入正负网络的参数，利用支路追加法形成阻抗矩阵Z12，Z0，AZ12，AZ0
//（2）读入故障信息，利用统一算法计算任意节点的各序故障电压和任意和任意支路的各序故障电流
//（3）故障类型为三相短路
//二、程序的输入和输出方式
//文件名：branch12.txt -正负序网络的参数
//支路类型--brancht12[]
//首节点--headnode12[]
//末节点--tailnode12[]
//电阻--RR12[]
//电抗--XX12[]
//接地电容或变比--BK12[]
//2.输出文件的形式
//output.txt--任意节点的各序故障电压和任意支路的各序故障电流
//三、程序中全局变量的说明：
//B12--正负序网络的支路数
//N0--零序网络的节点数
//B0--零序网络的支路数
//M--正负序网络的支路数
//M0--零序网络的支路数
//inv12[10] inv0[10]已经使用过的节点的标志
//四、源程序
#include <stdio.h>
//#include <stdafx.h>
//#include <stdith.h>
#include <complex>
//------------------------------------------------
//brancht12[]--支路类型
//headnode12[]--首节点
//tailnode12[]--末节点
//RR12[]--电阻
//XX12[]--电抗
//BK12[]--接地电容或变比
//N12--正负序网络的节点数
//B12--正负序网络的支路数
//N0--零序网络的节点数
//B0--零序网络的支路数
//M--正负序网络的支路数
//M0--零序网络的支路数
//inv12[10] inv0[10]已经使用过的节点的标志
//-------------------------------------------------
main()
{
    FILE*fp1,*fpb12,*fpb0;
    int i,j,k,l,m;
    int branchtype;
    float rr,xx,bbk;

    fp1=fopen("finfo.txt","r")
    fp12=fopen("branch12.txt","r")

  for(l=0;l<B12;l++)
  {
  fscanf(fpb12,"%d,%d,%d,%f,%f,%f",&branchtype,&i,&j,&rr,&xx,&&bbk);
  branchtype=branch12[L];
  i=headnode12[L];j=tailnode12[L];
  rr=RR12[L];xx=XX12[L];
  Bk12[l]=bbk;
  ZZ=COMPLEX[xx,rr];
  }

  }
  //read the fault information
  fscanf(fp1,",%d,%d,%f,%f",&faultnode,&linknode,&rf,&xf;
  fault();
  fclose(fp1);
  fclose(fp12);

  retrun 0;
  }
  //zhuluxinxihanshu
  void copybranchinfo()
   {
       int i,j;
       for(i=j=0;j<b12;i++)
           while(headnode12[i]!=tailnode12[i])
           {branchp[j][0]=headnode12[i];
            branchp[j][1]=tailnode12[i];
            branchp[j][2]=rr0[i];
            branchp[j][3]=xx0[i];
            j++;
           }
   }
//Calculate the initial voltage of all nodes
void Origpower()
{
  int i,j,NodeNum,PowerType;
  float PowerValueR,PowerValuex,rr,xx;
  complex zz;
  FILE *fp;
  if((fp=fopen("power.txt","r"))===NULL)
  {
      printf("cannot open file\n")
      exit(0);
   }
  while(!feof(fp))
  {
      fscanf(fp,"%d%f%f%d%f%f",&NodeNum,&PowerValuerR,&PowerValuex,&PowerType,&rr,&xx);
      if(PowerType==2) //Is current power
             origl[NodeNum-1]=complex(PowerValueR,PowerValueX);
      else
      {
             zz_complex(rr,xx);
             origl[NodeNum-1]=complex(PowerValueR,PowerValueX)/zz;
      }
  }
  for(i=0;i<n12;i++)origl_M[i]=origl[i];
  origl_M[N12M_1]=complex(0,0);
 //general the array of original node-volts
  for(i=0;i<N12;i++)
     for(j=0;j<N12;j++)
     origV[j]+=z12[i][j]*origl{j];
for(i=0;i<N12M;i++)
   for(j=0;j<N12M;j++)
       origV_m[i]+=AZ12[i][j]*origl_M[j];
//xingchengzukangjuzhen
void supperaddtion12()
main()
FILE*fpb12;
int i,j,k,l,m;
float rr,xx,bbk;
complex zz;
for(l=0;l<B12;l++)
{
    branchtype=brancht12[l];
    i=headnode12[l];
    j=tailnode12[l];
    rr=RR12[l];
    xx=XX12[l];
    zz=complex(rr,xx);
    i--;j--;
   if (((inv12[j]!=1&&(inv12[i]=1))||(i=j))
   {
      inv12[j]=1;
      if(branchtype=1);//the power branch
      {
          z12[j][j]=z12[i][i]+zz;
          for (k=0;k<n12;k++)
              if((inv[k]=1&&(k!=j))
         z12[k][j]=z12[k][i];
       }
       if(branchtype==2)//the transform branch
       {
           z12[j][j]=bbk*bbk*(z12[i][i]+zz);
           for(k=0;k<n12;k++)
                 if((inv[k]=1)&&(k!=j))
            z12[i][j]=bbk*z12[k][i];
           for(k=0;k<n12;k++)
           z12[j][k]=12[k][j];
        }
    }
    else if((inv12[i]!==1)&&(inv12[j]==1))
    {
        inv12[i]=1;//the used nodeid
        if(branchtype=1);//the power branch
        {
        z12[i][i]=z12[j][j]+zz;
   for(k=0;k<n12;k++)
              if((inv[k]=1)&&(k!=i))
           z12[k][i]=12[k][j];
   for(k=0;k<n12;k++)
       z12[i][k]=12[k][i];
z12[i][k]=12[k][i];
}
else if(branchtype==2)//the transform branch
{
    z12[i][i]=bbk*bbk*(z12[j][j]+zz);
 for(k=0;k<N12;k++)
 if((inv[k]==1)&&(k!=i))
 z12[k][i]=bbk*z12[k][j];
 for(k=0;k<N12;k++)
 z12[i][k]=z12[k][i];
}
}
else if((inv12[i]!==1)&&(inv12[j]==1))//the NO.i and NO.j nodes have used
{
if(branchtype==1);//the power branch
{
 for(k=0;k<N12;k++)
if(inv12[k]==1)
zll2[k]=z12[k][i]-z12[k][j];
zll12[k]=zl12[i]-zl12[j]+zz;
for(k=0;k<N12;k++)
for(m=0;m<N12;m++)
if((inv12[k]==1)&&(inv12[m]==1))
z12[k][m]=z12[k][m]-zl12[k]*zl12[m]/zll12;
}
else if(branchtype==2)//the transform branch
{
  for(k=0;k<N12;k++)
  if(inv12[k]==1)
 zl12[k]=bbk*z12[k][i]-z12[k][j];
     zll12=bbkzl12[i]-zl12[j]+bbk*bbk*zz;
for(k=0;k<N12;k++)
for(m=0;m<N12;m++)
if((inv12[k]==1)&&(inv12[m]==1))z12[k][m]=z12[k][m]-zl12[k]*zl12[m]/zll12;
}
}
}
//fclose(fpb12);
return;
}
//sanxiangduchulihanshu


void Three.ine(int fn)
{
     file*fp;
     int i,h,t;
     double rr,xx;
     fp=fopen("output.txt","w");
     complex fc,nodev[n12],ibranch[m][3],zz;
     fc=-origv[fn]/z12[fn][fn];
     
     fprintf(fp,"three phases short \n");
     fprintf(fp,"faultnode:%d\n\n",fn+1;
     for(i=0;i<n12;i++)
     {
         nodev[i]=origv[i]-origv[fn]*z12[fn][fn];
         printf(fp,"node%d:%f\n",i,real(nodev[i]),imag(nodev[i]))
      }
     for(i=0;i<m;i++)
     {
       h=branchp[i][0]-1;
       ibranchp[i][0]=h+1;
       t=branchp[i][1]-1;
       ibranchp[i][1]=t+1;
       rr=branchp[i][2];
       xx=branchp[i][3];
       zz=complex(rr,xx);
       ibranch[i][2]=(nodev[h]-nodev[t])/zz;
       count<<"BRANCH"<<H+1<<T+1<<":";
       count<<ibranch[i][2]<<"\nZ";
fprintf(fp,"BRANCH%d%d:%f+j%f\n",h+1,t+1,real(ibranch[i][2],imag(ibranch[i][2])
           imag(ibranch[i][2]));
       }
       }
   void common(complex nodev[n12][3],complex fc[3],int fn)
{
  file*fp;
  int i,j,h,t;
  double rp,xp;
  complex ibranch[m][5],zp;
  fp fopen("output.txt","a+");
  for(i=0;i<n12;i++)
  if(i!=fn)
  {
     if(i!<n0)
        nodev[i][0]=z0[fn][i]*fc[0];
     else
     nodev[i][0]=0;
     nodev[i][1]=origv[i]+fc[1]*z12[fn][i];
     nodev[i][2]=fc[2]*z12[fn][i];
   }
  
   for(i=0;i<m;i++)
   {
       h=branchp[i][0]-1;
       t=branchp[i][1]-1;
       rp=branchp[i][2];
       xp=branchp[i][3];
       zz=complex(rr,xx);
       ibranchp[i][0]=h+1;
       ibranchp[i][1]=t+1;
ibranch[i][3]=fc[1]*((origv[h]-origv[t])+z12[h][fn]-z12[t][fn]))/zp;
ibranch[i][4]=fc[2]*(z12[h][fn]-z12[t][fn]))/zp;
   }
   for(i=0;i<n12;i++)
   {
      count<<"node"<<i+1<<":";
      fprintf(fp,"node%d:",i+1);
      for(j=0;i<3;j++)
      {
      count<nodev[i][j]<<"\t");
      fprintf(fp,"%f+j%f\t",real(nodev[i][j]));
      }
     count<<"\n";
     fprintf(fp,"\n");
     count<<"branch";
     count<<real(ibranch[i][0])<<"-"<<real(ibranch[i][1])<<":";
fprintf(fp,"BRANCH%d%d:"int(real(ibranch[i][0],int(real(ibranch[i][1]))
   }
    for(j=2;j<5;j++)
    {
      count<<nodev[i][j]<<"\t";
       tprintf(fp,"%f+j%f\t",real(ibranch[i][j],imag(ibranch[i][j]);
    }
       count<<"\n";
       fprintf(fp,"\n--\n\n");
        fclose(fp);
}