s050710318 发表于 2009-1-10 13:30:12

我是电力的,研究电力优化领域!想结交楼主,向楼主学习!您能不能把你的测试数据发到论坛空间里来?

hifeel 发表于 2009-2-1 17:54:10

11、branch.h
//支路及节点参数输入头文件
//给节点电压赋初值以及确定结点给定的负荷和发电功率及给PV结点加标志
#include<time.h>
#include<stdlib.h>
#include<fstream.h>
#include<math.h>
#include<iostream.h>
#include<iomanip.h>
class Branch
{
public:
       int IZA;//支路状态数
       int IZ1;//支路一端结点号
       int IZ2;//支路另一端结点号
   int IWGA;//发电机状态数
       int IWG;//发电机节点号
   int IQ;//发电机台数
       double GV1;//发电机端电压的上限
       double GV2;//发电机端电压的下限
       double GQ1;//发电机无功出力上限
       double GQ2;//发电机无功出力下限
       double QG1;//节点发电机无功上限
       double QG2;//节点发电机无功下限
       double DQG;
   double VG1;//节点发电机端电压的上限
       double VG2;//节点发电机端电压的下限
       int ILP;//负荷状态数   
   int ILD;//负荷结点号
       int IPV;//PV结点的结点号
       double Z1;//支路正序电阻
       double Z2;//支路正序电抗
       double Z3;//支路正序电纳
       double Z4;//支路正序电纳暂存数组
       double W1;//发电机有功
       double W2;//发电机无功
   double WL1;//负荷有功
       double WL2;//负荷无功
       int N;//网络结点数
       int M;//网络支路数
       int No;//平衡节点号
       int IP;//负荷个数
       int N1;
       int popsize;//种群大小
        int NC;//可调无功补偿设备的台数
        int INC;//可调电容器的节点号
        int NC1;//电容器的挡数
        double CC1;//无功补偿容量的上限
        double CC2;//无功补偿容量的下限
        double CS;//无功补偿容量的分段步长
    int CN1;//节点电容器的挡数
    doubleJCC1;//节点无功补偿容量的上限
    double JCC2;//节点无功补偿容量的下限
    doubleSC;//节点无功补偿容量的分段步长
        int CK;//随机产生无功补偿装置的档位值
        double CK1;
        int NT;//变比可调的变压器台数
        int INT;//可调变压器号
       int NT1;//变压器可调挡数
   double TV1;//变压器变比的上限
   double TV2;//变压器变比的下限
   int TK1;//随机产生变压器分接头位置
       double TK2;
   double TS;//变压器变比分段步长
       double Uo;//平衡结点给定电压值
       double UP;//PQ结点电压初值
       double V;//存结点电压幅值
       double PV;//PV节点电压的中间变量
       double H;//存结点电压相角
       double PD;//存结点负荷的有功
       double QD;//存结点负荷的无功
       double PF;//存结点给定的发电有功
       double QF;//存结点给定的发电无功
       double BC;//节点无功补偿容量
       double LV1;//PQ节点电压的上限
       double LV2;//PQ节点电压的下限
       int IVI;//存PV结点的标志
public:
    void setdata();//随机产生初始变量
        void Read();//读入数据
        void init();//给结点电压赋初值,确定结点给定的负荷和发电功率及给PV结点加标志
};
12、branch.cpp
#include"branch.h"
//从a.txt文件读入数据
void Branch::Read()
{
       for(int g=0;g<=999;g++)
       {
               IZA=0;//支路状态数
               IZ1=0;//支路一端结点号
               IZ2=0;//支路另一端结点号
         IWGA=0;//发电机状态数
               IWG=0;//发电机节点号
               Z1=0;//支路正序电阻
               Z2=0;//支路正序电抗
               Z3=0;//支路正序电纳
               Z4=0;//支路电纳暂存数组
               GV1=0;//发电机端电压的上限
             GV2=0;//发电机端电压的下限
         GQ1=0;//发电机无功出力上限
             GQ2=0;//发电机无功出力下限
         QG1=0;//节点发电机无功上限
             QG2=0;//节点发电机无功下限
         DQG=0;
         VG1=0;//节点发电机端电压的上限
         VG2=0;//节点发电机端电压的下限
      PV=0;//PV节点电压的中间变量
               ILP=0;//负荷状态数   
               ILD=0;//负荷结点号
               W1=0;//发电机有功
               W2=0;//发电机无功
               WL1=0;//负荷有功
               WL2=0;//负荷无功
               V=0;//存结点电压幅值
              H=0;//存结点电压相角
               PD=0;//存结点负荷的有功
               QD=0;//存结点负荷的无功
               PF=0;//存结点给定的发电有功
               QF=0;//存结点给定的发电无功
               IVI=0;//存PV结点的标志
               IPV=0;//存PV结点的结点号
               PV=0;//存PV结点的电压
   
   INC=0;//无功补偿设备的节点号
       NC1=0;//电容器的挡数
   CC1=0;//无功补偿容量的上限
       CC2=0;//无功补偿容量的下限
   CS=0;//无功补偿容量的分段步长
      CN1=0;//节点电容器的挡数
      JCC1=0;//节点无功补偿容量的上限
          JCC2=0;//节点无功补偿容量的下限
      SC=0;//节点无功补偿容量的分段
          CK=0;
          CK1=0;
   BC=0;
          INT=0;//可调变压器号
          NT1=0;//变压器可调挡数
      TV1=0;//变压器变比的上限
      TV2=0;//变压器变比的下限
      TS=0;//变压器变比分段步长
          TK1=0;
          TK2=0;
        }
       ifstream aa("a.txt");
       aa>>N>>M>>No>>Uo>>IQ>>IP>>UP>>NC>>NT>>LV1>>LV2>>popsize>>N1;
       for(int h=1;h<=M;h++)
       {
               aa>>IZA;
               aa>>IZ1;
               aa>>IZ2;
               aa>>Z1;
               aa>>Z2;
               aa>>Z3;
       }
   for(int i=1;i<=IQ;i++)
       {
                aa>>IWGA;
                aa>>IWG;
      aa>>W1;
                aa>>W2;
                aa>>GV1;
          aa>>GV2;//发电机端电压的下限
      aa>>GQ1;//发电机无功出力上限
          aa>>GQ2;//发电机无功出力下限
       }
       for(int j=1;j<=IP;j++)
       {
               aa>>ILP;
               aa>>ILD;
               aa>>WL1;
               aa>>WL2;
       }
       for(int k=1;k<=N1;k++)
       {
               aa>>IPV;
              aa>>PV;
       }
       
   for(int m=1;m<=NC;m++)
   {
       aa>>INC;//无功补偿设备的节点号
       aa>>NC1;//电容器的挡数
   aa>>CC1;//无功补偿容量的上限
       aa>>CC2;//无功补偿容量的下限
   aa>>CS;//无功补偿容量的分段步长
   }
    for(int n=1;n<=NT;n++)//输入的时候按支路中变压器的顺序输入
    {
           aa>>INT;//可调变压器号
       aa>>NT1;//变压器可调挡数
       aa>>TV1;//变压器变比的上限
       aa>>TV2;//变压器变比的下限
       aa>>TS;//变压器变比分段步长
   }
       aa.close();
};
//给结点电压赋初值
void Branch::init()
{
        for(int I=1;I<=N;I++)
        {
                V=UP;
                H=0.0;
        }
        for(int I0=1;I0<=N1;I0++)
        {
                int J0=0;
                J0=IPV;
                V=PV;
        }
        V=Uo;
//确定结点给定的负荷和发电功率及给PV结点加标志
        for(int I1=1;I1<=IP;I1++)
        {
                if(ILP!=0)
                {
                        int J1=ILD;
                        PD=WL1;
                        QD=WL2;
                }
        }
        for(int I2=1;I2<=IQ;I2++)
        {
                if(IWGA!=0)
                {
                        int J2=IWG;
                        PF=W1;
                        QF=W2;
                  VG1=GV1;//节点发电机端电压的上限
            VG2=GV2;//节点发电机端电压的下限
            QG1=GQ1;//发电机无功出力上限
                QG2=GQ2;//发电机无功出力下限
                        DQG= QG1-QG2;
                }
        }
        for(int I3=1;I3<=N1;I3++)
        {
                int J3=IPV;
                IVI=1;
        }
        for(int I5=1;I5<=NC;I5++)
        {
                int J5=INC;//无功补偿设备的节点号
          CN1=NC1;//节点电容器的挡数
      JCC1=CC1;//节点无功补偿容量的上限
          JCC2=CC2;//节点无功补偿容量的下限
      SC=CS;//节点无功补偿容量的分段步长
      BC=0;//节点无功补偿容量
        }
       
};
void Branch::setdata()
{
    for(int k=2;k<=IQ;k++)//随机产生群体中第P个个体的发电机端电压变量的电压值并赋给确定的节点
        {
               int K1=IWG;
               V=rand()*(VG1-VG2)/32767.0+VG2;
        }
       for(int n=1;n<=NT;n++)//随机产生群体中第P个个体的变压器档位变量
       {
        TK1=(rand()%(NT1+1));
   Z3=TK1*TS+TV2;
       }
      for(int j=1;j<=NC;j++)//随机产生群体中第P个个体的电容器档位变量
          {
           int j1;
           j1=INC;
           CK=(rand()%(CN1+1));
          BC=CK*SC+JCC2;
           }
}
21、Ldp.h
//形成导纳矩阵头文件
//形成B`和B``
//形成功率误差分量dp,dq
#include"branch.h"
class LDP:public Branch
{
public:
        double D11;//正序导纳矩阵对角元的实部
        double D12;//正序导纳矩阵对角元的虚部
        double Y1;//正序导纳矩阵非对角非零元的实部
        double Y2;//正序导纳矩阵非对角非零元的虚部
        double YZ1;//不规则互导纳元素的实部
        double YZ2;//不规则互导纳元素的虚部
        int IY1;//不规则互导纳元素的行号
        int IY2;//不规则互导纳元素的列号
        int IY;//正序导纳矩阵非对角非零元的列号
        int In;//正序导纳矩阵每行非对角非零元的个数
        int IFD;//每行非对角非零元首元的地址
        int LF;//下一个可用的空白地址
        int LCOL;//各列非零元的首元地址
        int ITAG;//存放在CE中各元素的行指数
        int NOZE;//各列非零元素数(某一结点的“度”数加1,1为对角元素数)
        double CE1;//B`阵的有关元素
        double CE2;//B``阵的有关元素
        double DP;//dP/V
        double DQ;//dQ/V
        double AM;//DP,DQ中最大值;
public:
        void a();//形成导纳矩阵
        void d();//形成NOZE,ITAG数组及B`,B``元素
        void c1();//形成DP,DQ
};
22、Ldp.cpp

#include<math.h>
#include<iostream.h>
#include"Ldp.h"
//形成导纳矩阵
void LDP::a()
{
        int IG=0;//当前支路状态临时寄存单元
        double GIJ=0;//电导
        double BIJ=0;//电纳
        double GI=0;//I结点自导纳实部
        double GJ=0;//J结点自导纳实部
        double BI=0;//I结点自导纳虚部
        double BJ=0;//J结点自导纳虚部
        int L=0;
        double R=0;
        double X=0;
        double B=0;
        double A=0;
        int I8=0;
        int J8=0;
        for(int a=0;a<=999;a++)
        {
                D11=0;
                D12=0;
                Y1=0;
                Y2=0;
                IY=0;
                YZ1=0;
                YZ2=0;
                IY1=0;
                IY2=0;
                In=0;
                IFD=0;
                LCOL=0;
          ITAG=0;
//          LNXT=0;
          NOZE=0;
//          NSEQ=0;
                CE1=0;
                CE2=0;
                DP=0;
                DQ=0;
        }
        for(int j=1;j<=M;j++)
        {
                IG=IZA;
                if(IG==0)
                        continue;
                I8=IZ1;
                J8=IZ2;
                R=Z1;
                X=Z2;
                B=Z3;
                A=R*R+X*X;
                if(A==0)
                        continue;
                GIJ=R/A;
                BIJ=-X/A;
                if(IG==1)
                {
                        GI=GIJ;
            GJ=GIJ;
                        BI=BIJ+B/2;
                        BJ=BI;
                        D11=D11+GI;
                        D12=D12+BI;
                        D11=D11+GJ;
                        D12=D12+BJ;
                        L=L+1;
                        YZ1=-GIJ;
                        YZ2=-BIJ;
                        IY1=I8;
                        IY2=J8;
                        L=L+1;
                        YZ1=-GIJ;
                        YZ2=-BIJ;
                        IY1=J8;
                        IY2=I8;
                        continue;
                }
                else
                {
                        if((IG==2)||(IG==3))
                        {
                                GJ=GIJ;
                                BJ=BIJ;
                                GIJ=GIJ/B;
                                BIJ=BIJ/B;
                                GI=GIJ/B;
                                BI=BIJ/B;
                                D11=D11+GI;
                                D12=D12+BI;
                                D11=D11+GJ;
                                D12=D12+BJ;
                                L=L+1;
                                YZ1=-GIJ;
                                YZ2=-BIJ;
                                IY1=I8;
                                IY2=J8;
                                L=L+1;
                                YZ1=-GIJ;
                                YZ2=-BIJ;
                                IY1=J8;
                                IY2=I8;
                                continue;
                        }
                        else
                        {
                                D11=D11+GIJ;
                                D12=D12+BIJ;
                                continue;
                        }
                }
        }
//将不规则存放的互导纳有规则排列在Y1,Y2数组中
        int Jo;//有规则非零互导纳元素的计数单元(逐个累计)
        int Ko;//有规则非零互导纳元素的计数单元(逐行累计)
        int J1;//当前行I非零互导纳元素的计数单元,开始置零
        int K1,K2;//中间变量
        int J3;//中间变量
        Jo=0;
        Ko=0;
        for(int l=1;l<=N;l++)
        {
                J1=0;
                for(int K=1;K<=L;K++)
                {
                        if(IY1==l)
                                J3=IY2;
                        else
                                goto Loop;
                        for(K1=1;K1<=J1;K1++)
                        {
                                K2=Ko+K1;
                                if(J3==IY)
                                {
                                        Y1=Y1+YZ1;
                                        Y2=Y2+YZ2;
                                        goto Loop;
                                }
                        }
                        Jo=Jo+1;
                        Y1=YZ1;
                        Y2=YZ2;
                        IY=J3;
                        J1=J1+1;
Loop:
                        ;
                }               
                In=J1;
                Ko=Ko+J1;
        }
//确定每行非零非对角元首元的地址.//
        if(In==0)
                IFD=0;
        else
                IFD=1;
        for(int t=2;t<=N+1;t++)
                IFD=IFD+In;
};
//形成NOZE,ITAG数组及B`,B``元素
void LDP::d()
{
        int MID,MID1;
        double MID2,MID3;
        LCOL=1;
        int M1=1;
        int I4=1;
        LF=0;
        do
        {
                if(I4==No)
                {
                        ITAG=I4;
                        CE1=-D12-1.0e19;
                        CE2=-D12-1.0e19;
                }
                else
                {
                        if(IVI==1)
                        {
                                ITAG=I4;
                                CE1=-D12;
                                CE2=-D12-1.0e19;
                        }
                        else
                        {
                                ITAG=I4;
                                CE1=-D12;
                                CE2=-D12;
                        }
                }
                M1=M1+1;
          int Ji=IFD;       
                do
                {
                        ITAG=IY;
                        CE1=-Y2;
                        CE2=-Y2;
                        M1=M1+1;
                        Ji=Ji+1;
                }while(Ji<=(IFD-1));
                I4=I4+1;
                LCOL=M1;       
        }while(I4<=N);
        LF=M1;
        I4=M1;
        do
        {
                ITAG=0;
                CE1=0.0;
                CE2=0.0;
                I4=I4+1;
        }while(I4<=(M1+2*N));
        I4=1;
        do
        {
                I4=I4+1;
        }while(I4<=(M1+2*N));
        I4=2;
        int L4=0;
        do
        {
                L4=LCOL-1;
                I4=I4+1;
        }while(I4<=(N+1));
        I4=1;
loop3:
        int J4=LCOL;
loop4:
        MID=J4;
        MID1=ITAG;
        MID2=CE1;
        MID3=CE2;
        int K4=J4+1;
        do
        {
                if(ITAG<=ITAG)
                {
                        ITAG=ITAG;
                        CE1=CE1;
                        CE2=CE2;
                        MID=K4;
                }
                K4=K4+1;
        }while(K4<=(LCOL-1));
        ITAG=MID1;
        CE1=MID2;
        CE2=MID3;
        J4=J4+1;
        if(J4<(LCOL-1))
                goto loop4;
        else
                I4=I4+1;
        if(I4<=N)
                goto loop3;
        else
        {
                int s=1;
                do
                {
                        NOZE=LCOL-LCOL;
//                        NSEQ=s;
                        s=s+1;
                }while(s<=N);
        }
};       
//形成功率误差分量DP,DQ
void LDP::c1()
{
        AM=0;
        int J0;
        int Ms;
        double VB,VG,PI,QI;//中间变量
        double HIJ;//相角差
        for(int I0=1;I0<=N;I0++)
        {
                PI=0.0;
                QI=0.0;                               
                Ms=IFD;               
                do
                {
                        J0=IY;                               
                        VG=V*V*Y1;
                        VB=V*V*Y2;
                        HIJ=H-H;                                       
                        PI=PI+VG*cos(HIJ)+VB*sin(HIJ);
                        QI=QI+VG*sin(HIJ)-VB*cos(HIJ);
                        Ms=Ms+1;
                }while(Ms<IFD);
                PI=PI+D11*V*V;
                QI=QI-D12*V*V;
                if(I0==No)
                {
                        for(int G=1;G<=IQ;G++)
                        {
                                if(No==IWG)//平衡节点
                                {
                                        W1=PI;
                                        DP=0.00;
                                        W2=QI;
                                        DQ=0.00;
                                  goto loop12;
                                }
                        }                                               
                }               
                else
                {
                        for(int G=1;G<=IQ;G++)
                        {
                                if(I0==IWG)//发电机节点
                                {
                                        if(IVI!=1) //PQ节点
                                        {
                                                DP=(W1-PI)/V;
                                                DQ=(W2-QI)/V;
                                        }
                                        else//PV节点
                                        {
                                                DP=(W1-PI)/V;
                                                DQ=0.00;
                                                W2=QI;
                                        }
                                        for(int L0=1;L0<=IP;L0++)
                                        {
                                                if(I0==ILD)
                                                {
                                                        if(IVI==1)
                                                        {
                                                                DP=DP-WL1/V;
                                                                DQ=QI-WL2/V;
                                                                W2=DQ;
                                                                DQ=0.0;
                                                        }
                                                        else
                                                        {
                                                                DP=DP-WL1/V;
                                                                DQ=DQ-WL2/V;
                                                        }
                                                        goto loop12;
                                                }
                                        }
                                        goto loop12;
                                }
                        }
         for(int L2=1;L2<=NC;L2++)//无功补偿节点
                        {
                           if(I0==INC)
                                {
                                        DP=-PI/V;
                                        DQ=(BC-QI)/V;
                                for(int L3=1;L3<=IP;L3++)
                                        {
                                       if(I0==ILD)
                                       {
                     DP=DP-WL1/V;
                     DQ=DQ-WL2/V;
                                       goto loop12;
                                       }
                                        }
                          goto loop12;
                                }
                   }
                        for(int L1=1;L1<=IP;L1++)
                        {
                                if(I0==ILD)
                                {
                                        DP=-(PI+WL1)/V;
                                        DQ=-(QI+WL2)/V;
                                        goto loop12;
                                }
                        }
                        DP=-PI/V;
                        DQ=-QI/V;
                        goto loop12;
                }
        loop12:
                double C5=fabs(DP);
                double D5=fabs(DQ);
                if(C5>AM)
                        AM=C5;
                if(D5>AM)
                        AM=D5;
        }
}
31、ljp.h
//解稀疏方程组和计算支路潮流
#include"ldp.h"
class LJP:public LDP
{
public:
        double PFLOW;//存放支路正向有功
        double QFLOW;//存放支路正向无功
    double PFLOW1;//存放支路反向有功
        double QFLOW1;//存放支路反向无功
        double c;//临时变量
        double PLOS;//网络损耗
        double a1;//存放稀疏矩阵A中的非零元素的数组
        int a2;//存放稀疏矩阵A中的非零元素所在列号的数组
        int ma;//存放稀疏矩阵A中各行所具有的的非零元素的个数的数组
        double b;//存放方程组右端常数向量的数组,输出时用于存放方程组的解
        int nv,v2;//中间数组
        double wk,v1;//中间数组
public:
        void flo();//计算支路潮流
        void jfc(double A1[],int A2[],int MA[],double B[]);//解稀疏方程组
};
32、ljp.cpp
#include"ljp.h"

//计算支路潮流和网络损耗
void LJP::flo()
{
        for(int a=0;a<=999;a++)
        {
                PFLOW=0.0;
                QFLOW=0.0;
                PFLOW1=0.0;
                QFLOW1=0.0;
        }
        int I,J,IG;
        double A,B,A3,C3,D3,A5,B5;
        PLOS=0.0;
        for(int K=1;K<=M;K++)
        {
                I=IZ1;
                J=IZ2;
                IG=IZA;
                if(IG==0)
                        continue;
                if((Z1==0)&&(Z2==0))
                        continue;
                double E=V*cos(H);
                double F=V*sin(H);
                if(IG==4)
                {
                        A=0.0;
                        B=0.0;
                }
                else
                {
                        A=V*cos(H);
                        B=V*sin(H);
                }
                if((IG==2)||(IG==3))
                {
                        E=E/Z3;
                        F=F/Z3;
                        Z4=Z3;
                        Z3=0.0;
                }
                A3=Z1*Z1+Z2*Z2;
                C3=E-A;
                D3=F-B;
                A5=(C3*Z1+D3*Z2)/A3;
                B5=(D3*Z1-C3*Z2)/A3;
                C3=(E*E+F*F)*Z3/2.0;
                D3=(A*A+B*B)*Z3/2.0;
                PFLOW=E*A5+F*B5;
                QFLOW=F*A5-E*B5-C3;
                PFLOW1=-A*A5-B*B5;
                QFLOW1=-B*A5+A*B5-D3;
                if(IG==4)
                        continue;
                        PLOS=PLOS+PFLOW+PFLOW1;
                        if((IG==2)||(IG==3))
                                Z3=Z4;
        }
};
//解稀疏方程组
void LJP::jfc(double A1[],int A2[],int MA[],double B[])
{
        int i,j,k,l,ik,ii,jj,ll,j0;
        for(int y=0;y<=LF-2;y++)
        {
                a1=A1;
                a2=A2-1;
        }
        for(int z=0;z<=N-1;z++)
        {
                ma=MA;
                b=B;
        }
        for(int y1=0;y1<=999;y1++)
        {
                nv=0;
                v2=0;
                wk=0.000;
                v1=0.000;
        }
        ik=0;
        for(i=0;i<N;++i)
        {
                for(j=0;j<N;++j)
                        wk=0.000;
                c=0.0;
                for(l=0;l<ma;++l)
                {
                        j=a2;
                        wk=a1;
                        ik++;
                }
                jj=0;
                if(i!=0)
                {
                        for(l=0;l<i;++l)
                        {
                                ii=ma;
                                if(fabs(wk)>1.0e-8)
                                {
                                        if((ll=nv))
                                        {
                                                for(k=0;k<ll;++k)
                                                {
                                                        j=v2;
                                                        wk-=wk*v1;
                                                        ++jj;
                                                }
                                        }
                                        b-=wk*b;
                                        wk=0.000;
                                }
                                else
                                        jj+=nv;
                        }
                }
                l=0;
                for(j=0;j<N;++j)
                {
                        if((wk!=0.0)&&(fabs(wk)>fabs(c)))
                        {
                                c=wk;
                                j0=j;
                        }
                }
                if(fabs(c)<1.0e-10)
                        cout<<"方程组无解"<<endl;
                ma=j0;
                for(j=0;j<N;++j)
                {
                        if((wk!=0.0)&&(j!=j0))
                        {
                                v1=wk/c;
                                v2=j;
                                jj++;
                                l++;
                        }
                }
                nv=l;//注意区分l和1
                b/=c;
        }
        for(i=(N-1);i>=0;--i)
        {
                wk]=b;
                if(i==0)
                        continue;
                ii=nv;
                if(ii!=0)
                {
                        for(l=0;l<ii;++l)
                        {
                                --jj;
                                j=v2;
                                b-=wk*v1;
                        }
                }
        }
        for(i=0;i<N;++i)
                b=wk;       
}
41、yc.h
#include"ljp.h"
class YC:public LJP
{
public:
    LJP *gsign;
        //LJP *newpop;
    //LJP *p1;
    double *OV;//负荷节点电压越限量
        double *OQ;//发电机节点无功越限量
    double *fitnessv;//种群中个体的适应度
    double c;
        double favg;
        double fmin;
        double fmax;
        double fsum;
        int *AT;
        int maxpp;//本代个体适应值最大的个体号
        //int pop;
public:
        YC();
    ~YC();
        void powerf();
    void minmax();
};
42、yc.cpp
#include"yc.h"
YC::YC()
{
   favg=0;
       fmin=1.0;
   fmax=0;
       fsum=0;
        OV=new double;
        OQ=new double;
        gsign=new LJP;
        AT=new int;
        fitnessv=new double;
        for(int o=0;o<=49;o++)
        {
                OV=0;
      OQ=0;
                fitnessv=0;
               
        }
}
YC::~YC()
{
        delete[]OV;
        delete[]OQ;
        delete[]fitnessv;
        delete[]gsign;
        delete[]AT;
}
voidYC::powerf()
{
ofstream o("c.txt");
                                                                  
for(int p=0;p<=49;p++)
{
   gsign.Read();
       gsign.init();
   gsign.setdata();
       gsign.a();        //形成导纳矩阵
       gsign.d(); //形成NOZE,ITAG数组及B`,B``元素
       AT=0;//第P个个体的迭代次数
      do
                {
                gsign.c1();       
          gsign.jfc(gsign.CE1,gsign.ITAG,gsign.NOZE,gsign.DP);
                for(int k0=1;k0<=gsign.N;k0++)
                        gsign.H=gsign.H+gsign.b;
          gsign.jfc(gsign.CE2,gsign.ITAG,gsign.NOZE,gsign.DQ);
                for(int k1=1;k1<=gsign.N;k1++)
                  gsign.V=gsign.V+gsign.b;
                for(int k2=1;k2<=gsign.N1;k2++)
                {
                        int k3=gsign.IPV;
                        gsign.V=gsign.PV;
                }
                gsign.V.No]=gsign.Uo;
                gsign.H.No]=0.0;
          AT=AT+1;
        }while((gsign.AM>0.0001)&&(AT<200));
       
        for(int I3=1;I3<=gsign.IQ;I3++)
        {
                if(IWGA!=0)
                {
                        int J3=gsign.IWG;
                        gsign.PF=gsign.W1;
                        gsign.QF=gsign.W2;
                }
        }
    gsign.flo();//计算支路潮流和网损
       
    o<<"迭代次数"<<AT<<"   "<<"最大功率误差"<<gsign.AM<<endl;
        o<<"网络损耗"<<""<<gsign.PLOS<<""<<"平衡节点发电机出力"<<gsign.W1<<endl;
        o<<"节点"
                <<setiosflags(ios::left)<<""
                <<"电压幅值"
                <<setiosflags(ios::left)<<"   "
                <<"电压相角"
                <<setiosflags(ios::left)<<"   "
                <<"发电有功"
                <<setiosflags(ios::left)<<"   "
                <<"发电无功"
                <<setiosflags(ios::left)<<"   "
                <<"负荷有功"
                <<setiosflags(ios::left)<<"   "
                <<"负荷无功"<<endl;
        for(int e=1;e<=gsign.N;e++)
        {
                gsign.H=gsign.H*180/3.1416;
                o<<setw(3)<<e<<"    ";
                o<<setiosflags(ios::left)
                        <<setprecision(4)
                        <<setw(6)<<setiosflags(ios::showpoint)<<gsign.V<<"   "
                        <<setiosflags(ios::left)
                        <<setprecision(4)
                        <<setw(6)<<setiosflags(ios::showpoint)<<gsign.H<<"   "
                        <<setiosflags(ios::left)
                        <<setprecision(4)
                        <<setw(6)<<setiosflags(ios::showpoint)<<gsign.PF<<"   "
                        <<setiosflags(ios::left)
                        <<setw(6)<<setiosflags(ios::showpoint)<<gsign.QF<<"   "
                        <<setiosflags(ios::left)
                        <<setprecision(4)
                        <<setw(6)<<setiosflags(ios::showpoint)<<gsign.PD<<"   "
                        <<setiosflags(ios::left)
                        <<setw(6)<<setiosflags(ios::showpoint)<<gsign.QD<<endl;
        }
       
                for(int j=1;j<=gsign.N;j++)
                {
           if(j==gsign.IWG)
           {
          OV=OV+0;
           }
          else
          {
           if(gsign.V>gsign.LV1)
           {
                   OV=OV+(gsign.V-gsign.LV1)*(gsign.V-gsign.LV1)/(gsign.LV1-gsign.LV2)*(gsign.LV1-gsign.LV2);
           }
           else
           {
                   if(gsign.V>=gsign.LV2&&gsign.V<=gsign.LV1)
                   {
            OV=OV+0;
                   }
                   else
                   {
            OV=OV+(gsign.V-gsign.LV2)*(gsign.V-gsign.LV2)/(gsign.LV1-gsign.LV2)*(gsign.LV1-gsign.LV2);
                   }
           }
       }
   }
   
   for(int m=1;m<=gsign.IQ;m++)
   {
       if(gsign.QF>gsign.QG1)
                {
                 OQ=OQ+(gsign.QF-gsign.QG1)*(gsign.QF-gsign.QG1)/gsign.DQG*gsign.DQG;
                }
           else
           {
                if(gsign.QF>=gsign.QG2&&gsign.QF<=gsign.QG1)
                {
          OQ=OQ+0;
                }
                else
                {
         OQ=OQ+(gsign.QF-gsign.QG2)*(gsign.QF-gsign.QG2)/gsign.DQG*gsign.DQG;
                }
                }
   }

        fitnessv=100-gsign.PLOS-100*OV-OQ;
}
}
void YC::minmax()
{
        double temp;
for(int m1=0;m1<=49;m1++)
        {
   fsum=fsum+fitnessv;
   if(fitnessv<fmin)
   {
      fmin=fitnessv;
       }
       if(fitnessv>fmax)
       {
          fmax=fitnessv;
       }
        }
        for(int m2=0;m2<=49;m2++)
        {
                if(fitnessv==fmax)
                        maxpp=m2;
        }
    temp=fitnessv;
    fitnessv=fmax;
    fitnessv=temp;
        favg=fsum/50;

}
51、ccm.h
//交叉选择变异
#include"yc.h"
class COPY:public YC
{
public:
    double p1,p2;//适应度线性变换的参数
        doubler1;//介于0与总和之间的随机数
        int *gsymbol;//新一代群体中所取上一代个体号
        int *gnumber;//每个个体在新一代群体中的个数
        int gmark;//给需要交叉的个体加标志
        double pcross;//杂交概率
        double r4;//与交叉概率比较的随机数
        double pmutation;       

public:
        COPY();
        ~COPY();
        void choose();
        void crossover();
        void mutation();
    int round(double);
};
52、ccm.cpp
#include"ccm.h"
COPY::COPY()
{
        gsymbol=new int;
        gnumber=new int;
       
        for(int c0=0;c0<=49;c0++)
        {
                gsymbol=0;
                gnumber=0;
        }
}
COPY::~COPY()
{
        delete[]gsymbol;
        delete[]gnumber;
}

void COPY::choose()
{
        double part;
        p1=favg/(favg-fmin);
        p2=-fmin*favg/(favg-fmin);
    for(int c1=0;c1<=49;c1++)
        {
                fitnessv=p1*fitnessv+p2;
        }
    srand(5);   //随机数种子
        for(int c2=0;c2<=49;c2++)
        {
   int c3=0;
       part=0;
       r1=rand()*(p1*fsum+p2)/32767;//0与总和之间的随机数
       do
       {
          part=part+fitnessv;
                c3=c3+1;
       }
       while(part<r1&&c3<50);
   gsymbol=c3-1;
   cout<<gsymbol<<" ";//经过选择后新一代群体中所取上一代个体号
        }
   for(int i1=0;i1<=49;i1++)
        {
                for(int i2=0;i2<=49;i2++)
                {
                        if(gsymbol==i1)
                        {
                                gnumber+=1;
                        }
                        else
                        {
                                gnumber+=0;
                        }
                }
        cout<<"gnumber["<<i1<<"]= "<<gnumber<<endl;
        }
}
int COPY::round(double a)
{
        int t =(int)a;
        double temp =t+0.5;
        if (a>=temp)
        {
                return (t+1);
        }
        else
        {
                return t;
        }
       
};

void COPY::crossover()
{
for(int c4=0;c4<=49;c4++)
{
gmark=0;
r4=0;
}
        for(int i3=0;i3<=49;i3++)
        {
                if(gnumber!=0)
               {
                  r4=rand()/32767.0;//第i3号个体对应的随机数
        cout<<"r4["<<i3<<"]="<<r4<<endl;
              if(r4<pcross)
                  {
                  gmark=50;//给需要交叉产生的个体加标志
                  }
                }
        }
        gmark=0;//最好的个体不参加交叉
    for(int i4=0;i4<=49;i4++)//给待交叉个体选取父个体
        {
          int r5,r6;
          if(gmark==50)
          {
          r5=rand()%50;
                  if(gmark==50||gnumber==0)
                  {
                          do
                          {
                                  r5=rand()%50;
                          }
                          while(gmark==50||gnumber==0);
                  }
          r6=rand()%50;
                  if(gmark==50||gnumber==0)
                  {
                          do
                          {
                                  r6=rand()%50;
                          }
                          while(gmark==50||gnumber==0);
                  }
         for(int c5=2;c5<=6;c5++)//PV节点电压基因片的随机数
                        {       
                                int W1=gsign.IWG;
                        gsign.V=(gsign.V+gsign.V)/2;
         cout<<"gsign["<<i4<<"].V["<<W1<<"]=   "<<gsign.V<<endl;
                                       
                        }
         for(int c6=1;c6<=4;c6++)//变压器档位的交叉
                   {
                           int p1;
                          gsign.TK2=(gsign.TK1+gsign.TK1)/2;
                          p1=round(gsign.TK2);//变压器随机档位四舍五入取整
                          gsign.Z3=p1*gsign.TS+gsign.TV2;
                          cout<<"gsign["<<i4<<"].Z3["<<c6<<"]="<<gsign.Z3<<endl;
            }
         for(int c7=1;c7<=2;c7++)//无功补偿设备补偿容量的档位
                   {
                   int W2,p2;
                   W2=gsign.INC;
                   gsign.CK1=(gsign.CK+gsign.CK)/2;
                  p2=round(gsign.CK1);
                   gsign.BC=p2*gsign.SC+gsign.JCC2;
                   }
          }
        }
for(int i1=0;i1<=49;i1++)
{
                   cout<<"gnumber["<<i1<<"]"<<gnumber<<" ";
}
}
61、main.cpp
#include"ccm.h"
void main()
{
        COPY p1;//指向父代
    p1.powerf();
        p1.minmax();
        p1.choose();
        p1.crossover();

}
30 41 1 1.0500 6 21 1.0000 2 4 1.1 0.95 50 0
2 6 9 0.0000 0.2080 1
2 6 10 0.0000 0.5560 1
2 4 12 0.0000 0.2560 1
2 28 27 0.0000 0.3960 1
1 1 2 0.0192 0.0575 0.0528
1 1 3 0.0452 0.1852 0.0408
1 2 4 0.0570 0.1737 0.0368
1 3 4 0.0132 0.0379 0.0084
1 2 5 0.0472 0.1983 0.0418
1 2 6 0.0581 0.1763 0.0374
1 4 6 0.0119 0.0414 0.0090
1 5 7 0.0460 0.1160 0.0204
1 6 7 0.0267 0.0820 0.0170
1 6 8 0.0120 0.0420 0.0090
1 9 11 0.0000 0.2080 0.0000
1 9 10 0.0000 0.1100 0.0000
1 12 13 0.0000 0.1400 0.0000
1 12 14 0.1231 0.2559 0.0000
1 12 15 0.0662 0.1304 0.0000
1 12 16 0.0945 0.1987 0.0000
1 14 15 0.2210 0.1997 0.0000
1 16 17 0.0824 0.1932 0.0000
1 15 18 0.1070 0.2185 0.0000
1 18 19 0.0639 0.1292 0.0000
1 19 20 0.0340 0.0680 0.0000
1 10 20 0.0936 0.2090 0.0000
1 10 17 0.0324 0.0845 0.0000
1 10 21 0.0348 0.0749 0.0000
1 10 22 0.0727 0.1499 0.0000
1 21 22 0.0116 0.0236 0.0000
1 15 23 0.1000 0.2020 0.0000
1 22 24 0.1150 0.1790 0.0000
1 23 24 0.1320 0.2700 0.0000
1 25 26 0.2544 0.3800 0.0000
1 24 25 0.1885 0.3292 0.0000
1 25 27 0.1093 0.2087 0.0000
1 27 29 0.2198 0.4153 0.0000
1 27 30 0.3203 0.6027 0.0000
1 29 30 0.2399 0.4533 0.0000
1 828 0.0636 0.2000 0.0428
1 628 0.0169 0.0599 0.0130
1 1 0.9877 -0.0649 1.05 1.0 0.63 -0.2
1 2 0.8000 0.4171 1.05 1.0 0.6-0.2
1 3 0.5000 0.1666 1.05 1.0 0.63 -0.15
1 4 0.2000 0.2931 1.05 1.0 0.5 -0.15
1 5 0.2000 0.0671 1.05 1.0 0.4 -0.1
1 6 0.2000 0.0337 1.05 1.0 0.45 -0.15
1 2 0.2170 0.1270
1 3 0.9420 0.1900
1 4 0.3000 0.3000
1 7 0.2280 0.1090
1 8 0.0760 0.0160
1 10 0.0580 0.0200
1 11 0.0240 0.0120
1 12 0.1120 0.0750
1 14 0.0620 0.0160
1 15 0.0820 0.0250
1 16 0.0350 0.0180
1 17 0.0900 0.0580
1 18 0.0320 0.0090
1 19 0.0950 0.0340
1 20 0.0220 0.0070
1 21 0.1750 0.1120
1 23 0.0320 0.0160
1 24 0.0870 0.0670
1 26 0.0350 0.0230
1 29 0.0240 0.0090
1 30 0.1060 0.0190
10 5 0.5 0 0.1
24 5 0.1 0 0.02
1 8 1.1 0.9 0.025
2 8 1.1 0.9 0.025
3 8 1.1 0.9 0.025
4 8 1.1 0.9 0.025

迭代次数27   最大功率误差8.86593e-005
网络损耗0.0619842平衡节点发电机出力0.995987
节点电压幅值   电压相角   发电有功   发电无功   负荷有功   负荷无功
1      1.050      0.0000   0.9960   -0.06824   0.0000   0.0000
2      1.049      -1.487   0.8000   0.4171   0.2170   0.1270
3      1.010      -5.155   0.5000   0.1666   0.9420   0.1900
4      1.007      -5.294   0.2000   0.2931   0.3000   0.3000
5      1.041      -2.975   0.2000   0.06710   0.0000   0.0000
6      1.010      -5.378   0.2000   0.03370   0.0000   0.0000
7      1.014      -4.875   0.0000   0.0000   0.2280   0.1090
8      1.010      -5.620   0.0000   0.0000   0.07600   0.01600
9      1.064      -8.867   0.0000   0.0000   0.0000   0.0000
10   1.052      -10.65   0.0000   0.0000   0.05800   0.02000
11   1.061      -9.120   0.0000   0.0000   0.02400   0.01200
12   1.062      -10.39   0.0000   0.0000   0.1120   0.07500
13   1.062      -10.39   0.0000   0.0000   0.0000   0.0000
14   1.046      -11.23   0.0000   0.0000   0.06200   0.01600
15   1.041      -11.25   0.0000   0.0000   0.08200   0.02500
16   1.050      -10.77   0.0000   0.0000   0.03500   0.01800
17   1.046      -10.89   0.0000   0.0000   0.09000   0.05800
18   1.033      -11.73   0.0000   0.0000   0.03200   0.009000
19   1.031      -11.82   0.0000   0.0000   0.09500   0.03400
20   1.035      -11.58   0.0000   0.0000   0.02200   0.007000
21   1.037      -11.13   0.0000   0.0000   0.1750   0.1120
22   1.037      -11.12   0.0000   0.0000   0.0000   0.0000
23   1.028      -11.55   0.0000   0.0000   0.03200   0.01600
24   1.018      -11.61   0.0000   0.0000   0.08700   0.06700
25   0.9770   -10.66   0.0000   0.0000   0.0000   0.0000
26   0.9585   -11.11   0.0000   0.0000   0.03500   0.02300
27   0.9605   -9.794   0.0000   0.0000   0.0000   0.0000
28   1.011      -5.888   0.0000   0.0000   0.0000   0.0000
29   0.9392   -11.19   0.0000   0.0000   0.02400   0.009000
30   0.9269   -12.20   0.0000   0.0000   0.1060   0.01900
迭代次数22   最大功率误差9.074e-005
网络损耗0.06398平衡节点发电机出力0.9980
节点电压幅值   电压相角   发电有功   发电无功   负荷有功   负荷无功
1      1.050      0.0000   0.9980   -0.03941   0.0000   0.0000
2      1.048      -1.478   0.8000   0.4171   0.2170   0.1270
3      1.009      -5.132   0.5000   0.1666   0.9420   0.1900
4      1.005      -5.264   0.2000   0.2931   0.3000   0.3000
5      1.039      -2.973   0.2000   0.06710   0.0000   0.0000
6      1.007      -5.385   0.2000   0.03370   0.0000   0.0000
7      1.011      -4.879   0.0000   0.0000   0.2280   0.1090
8      1.005      -5.644   0.0000   0.0000   0.07600   0.01600
9      0.9452   -9.271   0.0000   0.0000   0.0000   0.0000
10   0.9525   -11.12   0.0000   0.0000   0.05800   0.02000
11   0.9425   -9.592   0.0000   0.0000   0.02400   0.01200
12   0.9696   -10.98   0.0000   0.0000   0.1120   0.07500
13   0.9696   -10.98   0.0000   0.0000   0.0000   0.0000
14   0.9542   -11.93   0.0000   0.0000   0.06200   0.01600
15   0.9508   -11.94   0.0000   0.0000   0.08200   0.02500
16   0.9547   -11.37   0.0000   0.0000   0.03500   0.01800
17   0.9474   -11.45   0.0000   0.0000   0.09000   0.05800
18   0.9381   -12.49   0.0000   0.0000   0.03200   0.009000
19   0.9340   -12.58   0.0000   0.0000   0.09500   0.03400
20   0.9378   -12.28   0.0000   0.0000   0.02200   0.007000
21   0.9427   -11.62   0.0000   0.0000   0.1750   0.1120
22   0.9445   -11.60   0.0000   0.0000   0.0000   0.0000
23   0.9456   -12.15   0.0000   0.0000   0.03200   0.01600
24   0.9477   -12.01   0.0000   0.0000   0.08700   0.06700
25   0.9977   -11.58   0.0000   0.0000   0.0000   0.0000
26   0.9797   -12.01   0.0000   0.0000   0.03500   0.02300
27   1.038      -11.00   0.0000   0.0000   0.0000   0.0000
28   0.9953   -5.979   0.0000   0.0000   0.0000   0.0000
29   1.018      -12.19   0.0000   0.0000   0.02400   0.009000
30   1.007      -13.05   0.0000   0.0000   0.1060   0.01900
迭代次数19   最大功率误差7.758e-005
网络损耗0.06740平衡节点发电机出力1.001
节点电压幅值   电压相角   发电有功   发电无功   负荷有功   负荷无功
1      1.050      0.0000   1.001      0.1956   0.0000   0.0000
2      1.039      -1.341   0.8000   0.4171   0.2170   0.1270
3      0.9949   -5.014   0.5000   0.1666   0.9420   0.1900
4      0.9882   -5.092   0.2000   0.2931   0.3000   0.3000
5      1.023      -2.782   0.2000   0.06710   0.0000   0.0000
6      0.9845   -5.143   0.2000   0.03370   0.0000   0.0000
7      0.9910   -4.668   0.0000   0.0000   0.2280   0.1090
8      0.9824   -5.415   0.0000   0.0000   0.07600   0.01600
9      0.9174   -9.306   0.0000   0.0000   0.0000   0.0000
10   0.8980   -11.48   0.0000   0.0000   0.05800   0.02000
11   0.9146   -9.647   0.0000   0.0000   0.02400   0.01200
12   0.9091   -11.40   0.0000   0.0000   0.1120   0.07500
13   0.9091   -11.40   0.0000   0.0000   0.0000   0.0000
14   0.8944   -12.48   0.0000   0.0000   0.06200   0.01600
15   0.8923   -12.55   0.0000   0.0000   0.08200   0.02500
16   0.8962   -11.81   0.0000   0.0000   0.03500   0.01800
17   0.8913   -11.86   0.0000   0.0000   0.09000   0.05800
18   0.8801   -13.12   0.0000   0.0000   0.03200   0.009000
19   0.8765   -13.19   0.0000   0.0000   0.09500   0.03400
20   0.8810   -12.84   0.0000   0.0000   0.02200   0.007000
21   0.8892   -12.12   0.0000   0.0000   0.1750   0.1120
22   0.8916   -12.12   0.0000   0.0000   0.0000   0.0000
23   0.8920   -12.94   0.0000   0.0000   0.03200   0.01600
24   0.9013   -13.00   0.0000   0.0000   0.08700   0.06700
25   0.9379   -12.17   0.0000   0.0000   0.0000   0.0000
26   0.9186   -12.67   0.0000   0.0000   0.03500   0.02300
27   0.9699   -11.34   0.0000   0.0000   0.0000   0.0000
28   0.9745   -5.773   0.0000   0.0000   0.0000   0.0000
29   0.9488   -12.72   0.0000   0.0000   0.02400   0.009000
30   0.9366   -13.71   0.0000   0.0000   0.1060   0.01900
迭代次数22   最大功率误差9.761e-005
网络损耗0.06019平衡节点发电机出力0.9942
节点电压幅值   电压相角   发电有功   发电无功   负荷有功   负荷无功
1      1.050      0.0000   0.9942   -0.003602   0.0000   0.0000
2      1.047      -1.447   0.8000   0.4171   0.2170   0.1270
3      1.006      -5.108   0.5000   0.1666   0.9420   0.1900
4      1.001      -5.229   0.2000   0.2931   0.3000   0.3000
5      1.037      -2.921   0.2000   0.06710   0.0000   0.0000
6      1.005      -5.311   0.2000   0.03370   0.0000   0.0000
7      1.009      -4.816   0.0000   0.0000   0.2280   0.1090
8      1.004      -5.561   0.0000   0.0000   0.07600   0.01600
9      0.9515   -9.321   0.0000   0.0000   0.0000   0.0000
10   0.9633   -11.21   0.0000   0.0000   0.05800   0.02000
11   0.9488   -9.638   0.0000   0.0000   0.02400   0.01200
12   0.9845   -11.07   0.0000   0.0000   0.1120   0.07500
13   0.9845   -11.07   0.0000   0.0000   0.0000   0.0000
14   0.9674   -12.02   0.0000   0.0000   0.06200   0.01600
15   0.9618   -12.03   0.0000   0.0000   0.08200   0.02500
16   0.9679   -11.44   0.0000   0.0000   0.03500   0.01800
17   0.9590   -11.52   0.0000   0.0000   0.09000   0.05800
18   0.9492   -12.55   0.0000   0.0000   0.03200   0.009000
19   0.9451   -12.64   0.0000   0.0000   0.09500   0.03400
20   0.9488   -12.35   0.0000   0.0000   0.02200   0.007000
21   0.9505   -11.75   0.0000   0.0000   0.1750   0.1120
22   0.9512   -11.74   0.0000   0.0000   0.0000   0.0000
23   0.9491   -12.31   0.0000   0.0000   0.03200   0.01600
24   0.9412   -12.29   0.0000   0.0000   0.08700   0.06700
25   0.9341   -11.47   0.0000   0.0000   0.0000   0.0000
26   0.9148   -11.97   0.0000   0.0000   0.03500   0.02300
27   0.9390   -10.66   0.0000   0.0000   0.0000   0.0000
28   1.002      -5.853   0.0000   0.0000   0.0000   0.0000
29   0.9172   -12.12   0.0000   0.0000   0.02400   0.009000
30   0.9045   -13.18   0.0000   0.0000   0.1060   0.01900
迭代次数23   最大功率误差9.035e-005
网络损耗0.05979平衡节点发电机出力0.9938
节点电压幅值   电压相角   发电有功   发电无功   负荷有功   负荷无功
1      1.050      0.0000   0.9938   -0.1285   0.0000   0.0000
2      1.051      -1.516   0.8000   0.4171   0.2170   0.1270
3      1.017      -5.167   0.5000   0.1666   0.9420   0.1900
4      1.015      -5.322   0.2000   0.2931   0.3000   0.3000
5      1.041      -3.024   0.2000   0.06710   0.0000   0.0000
6      1.010      -5.446   0.2000   0.03370   0.0000   0.0000
7      1.014      -4.934   0.0000   0.0000   0.2280   0.1090
8      1.008      -5.701   0.0000   0.0000   0.07600   0.01600
9      1.048      -9.118   0.0000   0.0000   0.0000   0.0000
10   1.028      -11.04   0.0000   0.0000   0.05800   0.02000
11   1.046      -9.379   0.0000   0.0000   0.02400   0.01200
12   0.9880   -10.30   0.0000   0.0000   0.1120   0.07500
13   0.9880   -10.30   0.0000   0.0000   0.0000   0.0000
14   0.9797   -11.21   0.0000   0.0000   0.06200   0.01600
15   0.9828   -11.39   0.0000   0.0000   0.08200   0.02500
16   0.9976   -10.96   0.0000   0.0000   0.03500   0.01800
17   1.014      -11.25   0.0000   0.0000   0.09000   0.05800
18   0.9862   -12.02   0.0000   0.0000   0.03200   0.009000
19   0.9915   -12.18   0.0000   0.0000   0.09500   0.03400
20   0.9999   -11.96   0.0000   0.0000   0.02200   0.007000
21   1.016      -11.49   0.0000   0.0000   0.1750   0.1120
22   1.016      -11.47   0.0000   0.0000   0.0000   0.0000
23   0.9887   -11.75   0.0000   0.0000   0.03200   0.01600
24   1.005      -11.83   0.0000   0.0000   0.08700   0.06700
25   1.025      -11.17   0.0000   0.0000   0.0000   0.0000
26   1.008      -11.59   0.0000   0.0000   0.03500   0.02300
27   1.046      -10.50   0.0000   0.0000   0.0000   0.0000
28   1.003      -6.024   0.0000   0.0000   0.0000   0.0000
29   1.027      -11.67   0.0000   0.0000   0.02400   0.009000
30   1.016      -12.52   0.0000   0.0000   0.1060   0.01900
迭代次数19   最大功率误差8.350e-005
网络损耗0.06471平衡节点发电机出力0.9987
节点电压幅值   电压相角   发电有功   发电无功   负荷有功   负荷无功
1      1.050      0.0000   0.9987   0.2126   0.0000   0.0000
2      1.039      -1.322   0.8000   0.4171   0.2170   0.1270
3      0.9945   -4.998   0.5000   0.1666   0.9420   0.1900
4      0.9877   -5.072   0.2000   0.2931   0.3000   0.3000
5      1.021      -2.752   0.2000   0.06710   0.0000   0.0000
6      0.9818   -5.100   0.2000   0.03370   0.0000   0.0000
7      0.9887   -4.632   0.0000   0.0000   0.2280   0.1090
8      0.9806   -5.363   0.0000   0.0000   0.07600   0.01600
9      0.9460   -9.314   0.0000   0.0000   0.0000   0.0000
10   0.9306   -11.49   0.0000   0.0000   0.05800   0.02000
11   0.9434   -9.635   0.0000   0.0000   0.02400   0.01200
12   0.9219   -11.15   0.0000   0.0000   0.1120   0.07500
13   0.9219   -11.15   0.0000   0.0000   0.0000   0.0000
14   0.9079   -12.22   0.0000   0.0000   0.06200   0.01600
15   0.9063   -12.31   0.0000   0.0000   0.08200   0.02500
16   0.9175   -11.67   0.0000   0.0000   0.03500   0.01800
17   0.9207   -11.82   0.0000   0.0000   0.09000   0.05800
18   0.9010   -12.92   0.0000   0.0000   0.03200   0.009000
19   0.9015   -13.03   0.0000   0.0000   0.09500   0.03400
20   0.9078   -12.72   0.0000   0.0000   0.02200   0.007000
21   0.9169   -12.09   0.0000   0.0000   0.1750   0.1120
22   0.9176   -12.08   0.0000   0.0000   0.0000   0.0000
23   0.9018   -12.68   0.0000   0.0000   0.03200   0.01600
24   0.9054   -12.71   0.0000   0.0000   0.08700   0.06700
25   0.9027   -11.82   0.0000   0.0000   0.0000   0.0000
26   0.8827   -12.35   0.0000   0.0000   0.03500   0.02300
27   0.9107   -10.93   0.0000   0.0000   0.0000   0.0000
28   0.9774   -5.676   0.0000   0.0000   0.0000   0.0000
29   0.8881   -12.49   0.0000   0.0000   0.02400   0.009000
30   0.8750   -13.62   0.0000   0.0000   0.1060   0.01900

hifeel 发表于 2009-2-4 19:41:33

求证你好求证你好求证你好求证你好

jimmy0415 发表于 2009-3-2 03:48:31

刚好在做配电网的无功优化,谢谢楼主共享了

wuhwul 发表于 2009-10-19 08:39:59

请问能不能发到我的邮箱wuhwul@126.com
谢谢

魏海啸 发表于 2010-3-27 21:45:49

谢谢分享,我程序还不是太懂,希望以后能看懂吧

lidongfu 发表于 2010-5-2 00:16:18

回复 1# hhuwjh


    谢谢

mitenike2004 发表于 2010-5-11 15:48:34

这个资料很有用!

冰ボ蔷薇 发表于 2010-5-18 22:32:46

楼主好人!!下来学习学习!!!

c123321 发表于 2010-7-6 21:39:24

谢谢,我想看看
页: 1 2 [3] 4 5
查看完整版本: 电力系统无功优化C++程序

招聘斑竹