jiedianpf.m

node insertion power flow

clc;
t0 = clock;
% t1=0;
% for i=1:100
    %% define named indices into bus, gen, branch matrices
    [PQ, PV, REF, NONE, BUS_I, BUS_TYPE, PD, QD, GS, BS, BUS_AREA, VM, ...
        VA, BASE_KV, ZONE, VMAX, VMIN, LAM_P, LAM_Q, MU_VMAX, MU_VMIN] = idx_bus;
    [F_BUS, T_BUS, BR_R, BR_X, BR_B, RATE_A, RATE_B, RATE_C, ...
        TAP, SHIFT, BR_STATUS, PF, QF, PT, QT, MU_SF, MU_ST, ...
        ANGMIN, ANGMAX, MU_ANGMIN, MU_ANGMAX] = idx_brch;
    [GEN_BUS, PG, QG, QMAX, QMIN, VG, MBASE, GEN_STATUS, PMAX, PMIN, ...
        MU_PMAX, MU_PMIN, MU_QMAX, MU_QMIN, PC1, PC2, QC1MIN, QC1MAX, ...
        QC2MIN, QC2MAX, RAMP_AGC, RAMP_10, RAMP_30, RAMP_Q, APF] = idx_gen;

    %% default arguments
    [baseMVA, bus, gen, branch, areas, gencost] =yangjiaping;
    [i2e, bus, gen, branch]=ext2int(bus, gen, branch);
    [ref, pv, pq]=bustypes(bus, gen);
    pqv=[pq;pv];
    Lpq=length(pq);
    Lpv=length(pv);
    Lpqv=Lpq+Lpv;
    Ltol=Lpqv+1;
    %形成节点导纳矩阵
    [Ybus, Yf, Yt]=makeYbus(baseMVA, bus, branch);
    %形成节点注入功率
    Sbus=makeSbus(baseMVA, bus, gen);
    G=real(Ybus);B=imag(Ybus);
    Ubus=ones(Ltol,1)*(1+0*j);
    on=find(gen(:, GEN_STATUS) > 0);                                %运行的机组
    gbus=gen(on, GEN_BUS);
    V=bus(:,VM) ; 
    V(gbus)=gen(on, VG) ;
    Ubus(ref)=V(ref);
    e=real(Ubus);
    f=imag(Ubus);
    Qi=(G*e-B*f).*f-(B*e+G*f).*e;
    Sbus(pv)=Sbus(pv)+j*Qi(pv);
    % Sbus(pv)=Sbus(pv)+[j*14.46,j*(-3.65)].'/100;
    Y=Ybus(pqv,pqv);
    G=real(Y);
    B=imag(Y);
    Matzr1=zeros(Lpq,Lpv);
    Matzr2=zeros(Lpv);
    %迭代计算
    for iter=1:100
        absV2=abs(Ubus).^2;                                             %迭代过程中的同一量
        absV4=absV2.^2;

        detI=Ybus*Ubus-conj(Sbus./Ubus);                                %计算所有的不平衡量
        detV=bus(:,VM).^2-absV2;
        detb=[  real(detI(pqv));
                imag(detI(pqv));
                detV(pv)          ];                %按照PQ、PV节点顺序取出不平衡量
    % %     t0 = clock;
        %计算雅可比矩阵
        ebus=real(Ubus);
        fbus=imag(Ubus);
        Pbus=real(Sbus);
        Qbus=imag(Sbus);

        %计算雅可比矩阵中变量
        dIre_de=-(Pbus.*(fbus.^2-ebus.^2)-2*ebus.*fbus.*Qbus)./absV4;   %H
        dIre_df=-(Qbus.*(ebus.^2-fbus.^2)-2*ebus.*fbus.*Pbus)./absV4;   %N
        dIim_de=dIre_df;                                                %J
        dIim_df=-(Pbus.*(ebus.^2-fbus.^2)+2*ebus.*fbus.*Qbus)./absV4;   %L
        dV_de=-2*ebus;                                                  %R
        dV_df=-2*fbus;                                                  %S
        dIre_dQ=-fbus./absV2;                                           %K
        dIim_dQ=ebus./absV2;                                            %M

        %形成雅可比矩阵中在迭代过程中发生变化的量(对角元素)
        dIre_de=dIre_de(pqv);                                           %形成H的对角元素组成的向量
        dIre_df=dIre_df(pqv);                                           %形成N的对角元素组成的向量
        dIim_de=dIim_de(pqv);                                           %形成J的对角元素组成的向量
        dIim_df=dIim_df(pqv);                                           %形成L的对角元素组成的向量

        H=spdiags(dIre_de,0,Lpqv,Lpqv);                                 %将形成的H向量的元素扩展对角矩阵
        N=spdiags(dIre_df,0,Lpqv,Lpqv);                                 %将形成的H向量的元素扩展对角矩阵
        J=spdiags(dIim_de,0,Lpqv,Lpqv);                                 %将形成的H向量的元素扩展对角矩阵
        L=spdiags(dIim_df,0,Lpqv,Lpqv);                                 %将形成的H向量的元素扩展对角矩阵
        R=spdiags(dV_de,0,Ltol,Ltol);                                   %将形成的H向量的元素扩展对角矩阵
        S=spdiags(dV_df,0,Ltol,Ltol);                                   %将形成的H向量的元素扩展对角矩阵

    % %     R=R(pv,pqv);                                                    %取出PV节点对应R
    % %     S=S(pv,pqv);                                                    %取出PV节点对应S

        K=diag(dIre_dQ(pv));                                            %将K扩展成对角阵
        M=diag(dIim_dQ(pv));                                            %将M扩展成对角阵

    % %     H=G+H;
    % %     N=-B+N;
    % %     J=B+J;
    % %     L=G+L;

        %组成雅克比矩阵
        Jac0=[(G+H),(-B+N);(B+J),(G+L)];
    % %     Jac0=[H,N;J,L];
        Jac1=[R(pv,pqv),S(pv,pqv)];
    % %     Matzr1=zeros(Lpq,Lpv);
    % %     Matzr2=zeros(Lpv);
        Jac2=[Matzr1;K;Matzr1;M;Matzr2];
    % %     Jac2=[Matzr1;diag(dIre_dQ(pv));Matzr1;diag(dIim_dQ(pv));Matzr2];

        Jac=[[Jac0;Jac1],Jac2];                                        %至此形成雅克比矩阵
    % %     Jac=[[H,N;J,L;R,S],Jac2];
    % %     et = etime(clock, t0);
    % %     t1=t1+et;
        %建立修正方程并求解
        dx=-(Jac\detb);

        %收敛性的判断
        if max(abs(dx))<1e-4;
           break
        end
        %修正量的求解
        ebus(pqv)=ebus(pqv)+dx(1:Lpqv);
        fbus(pqv)=fbus(pqv)+dx(Ltol:2*Lpqv);
        Ubus=ebus+j*fbus;
        Sbus(pv)=Sbus(pv)+j*dx(2*Lpqv+1:end);
    end                                                               %迭代过程结束
% end
% et = etime(clock, t0);
a=abs(Ubus);