pq_powerflow.txt

PQ分解法潮流程序,Ｃ语言编写

        NodePow[i].P=0.0;
    else
        NodePow[i].Q=0.0;
  }
    
    

  for(i=1;i<=N;i++)
  {
    Vi=NodeVol[i].V;

    if(flag==1)
    {
        A=Yii[i].G;
    }
    else
    {
        A=-Yii[i].B;
    }
        
    if(flag==1)
        NodePow[i].P+=Vi*Vi*A;
    else
        {NodePow[i].Q+=Vi*Vi*A;}
        
    if(i==N)
    {
        break;
    }
    else
    {
        
        for(n=NYseq[i];n<=NYseq[i+1]-1;n++)
        {
            if(flag==1)
            {
                A=Yij[n].G;
                B=Yij[n].B;
            }
            else
            {
                A=-Yij[n].B;
                B=Yij[n].G;
            }
            j=Yij[n].j;
            VV=Vi*NodeVol[j].V;
            theta=NodeVol[i].theta-NodeVol[j].theta;
            A=A*VV*cos(theta);
            B=B*VV*sin(theta);
            if(flag==1)
            {
                NodePow[i].P+=(A+B);
                NodePow[j].P+=(A-B);
            }
            else
            {
                NodePow[i].Q+=(A+B);
                NodePow[j].Q+=(A-B);
            }
        }
    }
    
  }
    
}







void Iteration(int flag,struct Generator_Type *Generator,struct Load_Type *Load,struct PVNode_Type *PVNode,struct NodalVol *NodeVol,struct NodalPow *NodePow,struct GeneratorPower *GenPower,int N,double *DI,double *MaxError,int *ErrNode)
{
    /*迭代函数*/
   

  int i=1,n_g=1,n_l=1,n_pv=1,i_g=Generator[1].i,i_l=Load[1].i,i_pv=PVNode[1].i;
  double Vi,Wi,Wtemp;
    

  (*MaxError)=0.0;

    

    
  do
  {
    Vi=NodeVol[i].V;

    if(i==i_l)      
    {
        if(flag==1)
        {
            Wi=Load[n_l].P;
        }
        else
        {
            Wi=Load[n_l].Q;
        }
        n_l+=1;
        i_l=Load[n_l].i;
    }
    else
    {
        Wi=0.0;
    }
    Wtemp=Wi;
    if(flag==1)
        Wi=Wi-NodePow[i].P;
    else
        Wi=Wi-NodePow[i].Q;


    if(i==i_g)
    {
        if(flag==1)
        {
            NodePow[i].P=Wtemp;
            GenPower[i_g].P=-Wi;
        }
        else
        {
            NodePow[i].Q=Wtemp;
            GenPower[i_g].Q=-Wi;
        }


        if(flag==1)
        {
            Wi+=Generator[n_g].P;
        }
        else
        {
            Wi+=Generator[n_g].Q;
        }
        n_g+=1;
        i_g=Generator[n_g].i;
    }
        

    if(i==N)
    {
        break;/*退出循环，进行MaxError与epsilon的比较*/
    }
    else
    {
        if(flag==2&&i==i_pv)
        {
            n_pv+=1;
            i_pv=PVNode[n_pv].i;
            DI[i]=0.0;
        }
        else
        {
            if(fabs(Wi)>(*MaxError))
            {
                (*MaxError)=fabs(Wi);
                (*ErrNode)=i;
            }
                
            DI[i]=Wi/Vi;
        }
        
    }i+=1;

  }while(1);
    
    
}





void FormulaSolution(int flag,struct U_Type *U,double *D,int *NUsum,double *DI,int N,struct NodalVol *NodeVol,double V0)
{

    /*迭代完成后，进行线性方程组的求解*/
  int n_u;
  int i,count;
  int j;
  double DItemp,Dtheta,DV;
  n_u=1;
    
  for(i=1;i<=N-1;i++)
  {
    DItemp=DI[i];
    for(count=1;count<=NUsum[i];count++)
    {
        j=U[n_u].j;
        DI[j]=DI[j]-DItemp*U[n_u].value;
        n_u++;
    }
    DI[i]=DItemp*D[i];
  }
  for(i=N-1;i>=1;i--)
  {
    DItemp=DI[i];
    for(count=1;count<=NUsum[i];count++)
    {
        n_u-=1;
        j=U[n_u].j;
        DItemp=DItemp-DI[j]*U[n_u].value;
    }
    DI[i]=DItemp;
  }




  for(i=1;i<=N-1;i++)
  {
    if(flag==1)
    {
        Dtheta=DI[i]/V0;
        NodeVol[i].theta=NodeVol[i].theta-Dtheta;
    }
    else
    {
        DV=DI[i];
        NodeVol[i].V-=DV;
    }
  }

 

}



void NodeDataOutput(FILE *fp,struct NodalVol *NodeVol,struct Generator_Type *Generator,int N,struct GeneratorPower *GenPower,struct NodalPow *NodePow,struct Load_Type *Load,int Nl)
{
    /*节点数据输出*/
  double Vmin=NodeVol[1].V;
  double V,theta,P,Q,temp;
  int i_g=Generator[1].i;
  int VminNode=1;
  int n_g=1;
  int i;
    
  for(i=1;i<=N;i++)
  {
    theta=NodeVol[i].theta/3.14159*180;
    if(theta>180||theta<-180)
    {
        theta=(int)theta%360+modf(theta,&temp);
        if(theta>180)
            theta-=360;
        else
        if(theta<-180)
            theta+=360;
    }
    V=NodeVol[i].V;
    if(V<Vmin)
    {
        Vmin=V;
        VminNode=i;
    }
    else
    {
        ;
    }
    if(i==i_g)
    {
        P=GenPower[i].P;
        Q=GenPower[i].Q;
        n_g+=1;
        i_g=Generator[n_g].i;
    }
    else
    {
        P=0.0;
        Q=0.0;
    }
    if(i!=N)
        fprintf(fp,"  %d\t   %10.7lf\t   %10.7lf\t  %10.7lf\t  %10.7lf\n",i,V,theta,P,Q);
    else
        fprintf(fp,"  %d\t   %10.7lf\t   %10.7lf\t  %10.7lf\t  %10.7lf\n",i,V,theta,NodePow[i].P-Load[Nl].P,NodePow[i].Q-Load[Nl].Q);

  }
    fprintf(fp,"系统最低电压=%10.7lf,节点=%d\n",Vmin,VminNode);
}



void BranchDataOutput(FILE *fp,int Nb,int Nc,int Nr,struct Branch_Type *Branch,struct Compensation_Type *Compensation,struct Reactance_Type *Reactance,struct NodalVol *NodeVol)
{
  /*支路数据输出*/
  double PLoss=0.0,QLoss=0.0;
  int n;
  int i,j;
  double R,X,YK,Y,theta,Ei,Ej,Fi,Fj,Vi,Vj,DE,DF;
  double Zmag2,Ir,Ii;
  double Pij,Qij,Pji,Qji;
  for(n=1;n<=Nb;n++)
  {
    i=abs(Branch[n].i);
    j=abs(Branch[n].j);
    R=Branch[n].R;
    X=Branch[n].X;
    YK=Branch[n].YK;

    Vi=NodeVol[i].V;
    theta=NodeVol[i].theta;
    Ei=Vi*cos(theta);
    Fi=Vi*sin(theta);

    Vj=NodeVol[j].V;
    theta=NodeVol[j].theta;
    Ej=Vj*cos(theta);
    Fj=Vj*sin(theta);
            
    if(Branch[n].i<0||Branch[n].j<0)
    {
        if(Branch[n].i<0)
        {
            Ei=Ei/YK;
            Fi=Fi/YK;
        }
        else
        {
            Ej=Ej/YK;
            Fj=Fj/YK;
        }
        YK=0.0;
    }
    else
    {
        ;
    }
            
    DE=Ei-Ej;
    DF=Fi-Fj;
    Zmag2=R*R+X*X;
    Ir=(DE*R+DF*X)/Zmag2;
    Ii=(DF*R-DE*X)/Zmag2;
            
    Pij=Ir*Ei+Ii*Fi;
    Qij=Ir*Fi-Ii*Ei;
            
    Pji=-(Ir*Ej+Ii*Fj);
    Qji=-(Ir*Fj-Ii*Ej);
            
    Qij-=(Vi*Vi*YK/2.0);
    Qji-=(Vj*Vj*YK/2.0);
            
    PLoss=PLoss+Pij+Pji;
    QLoss=QLoss+Qij+Qji;
            
    fprintf(fp,"  %3d->%3d\t   %10.7lf\t   %10.7lf\n  %3d->%3d\t   %10.7lf\t   %10.7lf\n",i,j,Pij,Qij,j,i,Pji,Qji);
  }
  for(n=1;n<=Nc;n++)
  {
    i=Compensation[n].i;
    Y=Compensation[n].Y;

    Vi=NodeVol[i].V;

    Qij=-(Vi*Vi*Y); 

    QLoss=QLoss+Qij;

    fprintf(fp,"  %3d->0  \t\t\t\t\t   %10.7lf\n",i,Qij);
  }
  for(n=1;n<=Nr;n++)
  {
    i=Reactance[n].i;
    X=Reactance[n].X;

    Vi=NodeVol[i].V;

    Qij=Vi*Vi/X;   

    QLoss=QLoss+Qij;

    fprintf(fp,"  %3d->0  \t\t\t\t\t\t\t   %10.7lf\n",i,Qij);
  }


  fprintf(fp,"     损耗\t   %10.7lf\t   %10.7lf\n",PLoss,QLoss);
         
}

下面是数据输入格式说明：
为了减少不必要的运算，本潮流程序中将严格规定数据的录入格式.
具体要求如下：
1.数据共分六大组：即基本数据组、支路数据组、补偿电容数据组、并联电抗数据组、发电机节点数据组、负荷节点数据组。

2.在基本数据组内按照以下格式录入以下数据：
  节点个数，支路条数，对地补偿电容支路数，并联电抗数、发电机节点个数，负荷节点个数，系统平均电压，计算精度

3.在支路数据组内按照以下格式录入以下数据：
  对于线路支路：  支路的第一个节点号，支路的第二个节点号，支路的电阻，支路的电抗，支路的导纳
  对于变压器支路：变压器的第一个节点号，变压器的第二个节点号，变压器的电阻，变压器的电抗，变压器的非标准变比
注意：（1）支路两端的节点号应把小号排在前面，大号排在后面；
  （2）各支路按其小节点号的顺序排列；
  （3）对于线路支路，导纳应为Y,而不是计算中的Y/2;
  （4）对于变压器支路，变压器非标准变比所在侧的节点号应为负号。
另外，串联电容也应该在系统中被认为是一条支路，且串联电容的参数应当换算成为相应的电抗值，注意：此值为负。
特别提醒：本程序不支持同节点之间的并联线路，需要先行归化为一条线路，然后求解。

4.在补偿电容数据组内按照以下格式录入以下数据：
  所在节点号、导纳值

5.在并联电抗数据组内按照以下格式录入以下数据：
  所在节点号、电抗值

6.在发电机节点数据组内按照以下格式录入以下数据：
  发电机所在节点号，发电机所发有功，发电机所发无功，发电机节点的电压
注意：（1）对于PV节点，无功应为发电机的无功上限；
  （2）对于PV节点，电压为节点所需维持的电压，应为负值；
  （3）对于PQ节点，电压为计算过程中的节点的电压初值。

7.在负荷节点数据组内按照以下格式录入以下数据：
  负荷所在节点号，负荷有功，负荷无功，负荷节点的电压
注意：（1）负荷节点一般为PQ节点，其电压为计算过程中的节点的电压初值；
  （2）负荷的有功和无功均应写成注入节点功率的形式，即全部为负值；
  （3）特别的，系统的平衡节点应该被排在最后，即作为第N个节点，同时要求该节点为负荷节点；如果该点无负荷，则该点的负荷功率填零。

至于对所求解系统的描述性文字可以放在该文件的末尾，任意长度。
另外，本程序可以自动形成输出文件，其文件名为输入文件名后加“out”，且输出文件名的后缀确定为“.dat”。例如，对于程序已给的5节点系统，输入文件名“ps-5”，后缀为“.dat”，输出文件名为“ps-5out”，后缀为“.dat”。为了保证名称的前后统一，因此建议：将输入文件的名字写成如下格式：****.dat;并且输入文件的文件名的长度应不大于5（不计后缀）。 
5,5,0,0,1,4,1.0,0.00001
1,2,0.04,0.25,0.5
1,3,0.1,0.35,0.0
2,3,0.08,0.3,0.5
-2,4,0.0,0.015,1.05
-3,5,0.0,0.03,1.05
4,5.0,3.0,-1.05
1,-1.6,-0.8,1.0
2,-2.0,-1.0,1.0
3,-3.7,-1.3,1.0
5,0.0,0.0,-1.05