formback11.m

利用前推回代法

%%% 单位:电流单位为A,电压单位为kV，功率单位为kW，阻抗单位为欧姆
function [U,iterations,error,costime]=formback
t1=clock;
bus16;%% 导出networkdata文件中的data矩阵,和网络的输入端的额定电压为Un，网络的参数都存储在data中
%%global A;
global Ibr;
A=data;  %%% 输入参数矩阵A说明：矩阵A的行数为配电网的支路数，共6列，第1列
[Rower,Column]=size(A);
Nodes=Rower+1;
Zbr=A(:,3)+j*A(:,4);
Srnode=A(:,5)+j*A(:,6);
fork=0;%% 定义fork为存储分叉节点的行向量，其初始值为一个数0，即行向量fork的第一列为0

%% 搜索分叉节点，并将所有的分叉节点存在向量fork里面，除第一列外
%% 搜索分叉节点，并将所有的分叉节点存在向量fork里面，除第一列外
for ii=1:Rower-1
    k=0;
    [r,fsize]=size(fork); %% 取行向量fork的长度为fsize
    for jj=ii+1:Rower
        if A(ii,1)==A(jj,1)
            %% 判断分叉节点A(i,1)是否已经被保存过？
            for m=1:fsize
                if A(jj,1)==fork(m)
                    k=1;  %% k=1，表示分叉点已经被保存过，k=0,表示没有保存过
                end
            end
            %% 判断分叉节点A(i,1)是否已经被保存过？
            if k==0
                fork=[fork,A(ii,1)]; %% 保存分叉节点A(i,1)
            end
            break  %% 当搜索到分叉点后立即退出搜索,返回重新搜索
        end
    end
end
%% 搜索分叉节点，并将所有的分叉节点存在向量fork里面，除第一列外
%% 搜索分叉节点，并将所有的分叉节点存在向量fork里面，除第一列外

%% 搜索末节点
%% 搜索末节点
End=[0,0]; %% 定义End为存储末端节点的两列矩阵，第一列为末端节点所在的行,第二列为末端节点编号;其初始值为[0,0]，即End的第一行为0
for ii=1:Rower
    k=0;
    for jj=1:Rower
        if A(ii,2)==A(jj,1)
            k=1; %% 搜索有没有与受端节点相同的送端节点,如果有使k=1,说明该受端节点不是末节点
            break
        end
    end
    if k==0
        End=[End;[ii,A(ii,2)]]; %% k=0,表示受端节点是末节点，将A(ii,2)存储在End行向量中
    end
end
%% 搜索末节点
%% 搜索末节点

[r,fsize]=size(fork);[esize,c]=size(End);
forknods=fork(2:fsize); %% 取出所有的分叉节点存放在行向量forknods中
endnods=End(2:esize,:); %% 取出所有的末端节点存放在矩阵endnods中,第一列表示末端节点所在支路在矩阵A中的行数,第二列表示末端节点的编号
%%global Unods;
Unods(Rower,3)=0; 
Unods(:,1:2)=A(:,1:2); %% Unods第一列表示支路的送端节点编号,第二列表示受端节点编号,第三列表示受端节点电压
Unods(:,3)=Un/Ubse; %% 定义所有受端节点的电压的初始值均为额定电压值Un,Ubse为基准值

accuracy=1.0e-8;
error=Un;
iterations=0;

while error>accuracy
      iterations=iterations+1;
      Uabs1=abs(Unods(:,3));
%% 利用前推法求解各支路的电流值
%% 利用前推法求解各支路的电流值
      Inlp(Rower,3)=0;  %% 定义节点负荷电流存储矩阵
      Inlp(:,1:2)=A(:,1:2); %% Inlp的第一列存储送端节点的编号,第二列存储受端节点的编号,第三列存储受端节点的负荷电流(初始值为0)
      Inlp(:,3)=conj(Srnode./Unods(:,3)); %% 求解受端节点的负荷电流

      [r,fsize]=size(forknods);
      [endsize,c]=size(endnods);

      Ibr(Rower,3)=0;  %% 定义支路负荷电流存储矩阵
      Ibr(:,1:2)=A(:,1:2);  %% Ibr的第一列存储送端节点的编号,第二列存储受端节点的编号,第三列存储支路的负荷电流(初始值为0)
      fork1=0;
      for ii=1:endsize
          Ibr(endnods(ii,1),3)=Inlp(endnods(ii,1),3); %% 将末端节点的负荷电流赋给所连分支的分支电流
          Sendnod=Ibr(endnods(ii,1),1); %% Sendnod为之路的送端节点编号，它随之路的不同而变化的
          I=Ibr(endnods(ii,1),3);  %% 定义临时支路电流，它也随之路的不同而变化的
          k=0;
          kk=0;
          while kk<=Rower
                kk=kk+1;
                for jj=1:fsize
                    %%if Ibr(Sendnod,1)==forknods(jj)
                    if Sendnod==forknods(jj)
                       k=1;  %% 如果支路送端节点Sendnod是分叉节点的话，则赋给k=1,并退出本层循环体
                       break
                    end
                end
                if k==1
                    i1=1;
                    [r7,fsize1]=size(fork1);
                    for mm=1:fsize1
                        if Sendnod==fork1(mm)
                            i1=i1+1;
                        end
                    end
                    if i1==1
                        fork1=[fork1,Sendnod];
                    end
                    break   %% 如果k等于1,则表示支路的送端节点为分叉节点,退出本层循环体
                end
                %% 寻找受端节点是节点Sendnod的支路
                if Ibr(kk,2)==Sendnod
                   Ibr(kk,3)=I+Inlp(kk,3); %% 受端节点是节点Sendnod的支路的电流=送端节点是Sendnod的支路的电流+受端节点Sendnod处的负荷电流
                   Sendnod=Ibr(kk,1); %% 更新送端节点编号Sendnod为新支路的送端节点编号
                   I=Ibr(kk,3); %% 更新支路电流为新支路的支路电流
                   kk=0;
                end
                %% 寻找受端节点是节点Sendnod的支路
          end
      end
%% 由于在节点编号时有意将分叉点由小到大排列，由大的分叉点向小的分叉点聚拢，最后聚拢到一条支路上
      [r6,fsize1]=size(fork1);
      fork1=fork1(:,2:fsize1);;
      [r6,fsize1]=size(fork1);
      for n=1:fsize1             %% 交叉点由大到小循环
          Sendnod=fork1(n);
          I=0;
          for m=1:Rower
              if Ibr(m,1)==Sendnod  %% 寻找送端节点是交叉节点的支路
                 I=I+Ibr(m,3); %% 计算从交叉点流向其它分支的的总的电流，不包括节点Sendnod的负荷电流
              end
          end
          k=0;
          kk=0;
          while kk<Rower
                kk=kk+1;
                if Ibr(kk,2)==Sendnod  
                   Ibr(kk,3)=I+Inlp(kk,3); %% 计算受端节点为Sendnod的支路的电流 
                   Sendnod=Ibr(kk,1);
                   kk=0;
                   for nn=1:fsize1
                       if Sendnod==fork1(nn)
                          k=1; %% 如果受端节点为Sendnod的支路的送端节点编号是交叉点，则退出
                          break
                       end
                   end
                end
                if k==1
                   break
                end
          end
      end
%% 利用前推法求解各支路的电流值
%% 利用前推法求解各支路的电流值

%% 利用回代法求解各支路的电流值
%% 利用回代法求解各支路的电流值            
      Sendnode=A(1,1); %Ufn=Un; %% Sendnode为首端节点编号，Ufn为首端节点电压，一般为额定值不变
      %Uupnode=Ufn;
      for ii=1:Rower               %%有问题
          %if Ibr(ii,1)==Sendnode
              %Unods(ii,3)=Un;
          %end
          for jj=1:Rower
              if Ibr(jj,1)==Sendnode
                  Unods(jj,3)=Un/Ubse-Zbr(jj)*Ibr(jj,3);
              elseif Ibr(jj,1)==Ibr(ii,2)
                  Unods(jj,3)=Unods(ii,3)-Zbr(jj)*Ibr(jj,3);
              end
          end
      end   
      %%% 利用回代法求解各支路的电流值
      %%% 利用回代法求解各支路的电流值 
      Uabs2=abs(Unods(:,3));
      error=max(Uabs1-Uabs2);
end
%% 利用最终计算所得到的节点电压值重新计算各分支电流
%% 利用最终计算所得到的节点电压值重新计算各分支电流
Inlp(Rower,3)=0;  %% 定义节点负荷电流存储矩阵
      Inlp(:,1:2)=A(:,1:2); %% Inlp的第一列存储送端节点的编号,第二列存储受端节点的编号,第三列存储受端节点的负荷电流(初始值为0)
      Inlp(:,3)=conj(Srnode./Unods(:,3)); %% 求解受端节点的负荷电流

      [r,fsize]=size(forknods);
      [endsize,c]=size(endnods);
      Ibr(Rower,3)=0;  %% 定义支路负荷电流存储矩阵
      Ibr(:,1:2)=A(:,1:2);  %% Ibr的第一列存储送端节点的编号,第二列存储受端节点的编号,第三列存储支路的负荷电流(初始值为0)

      for ii=1:endsize
          Ibr(endnods(ii,1),3)=Inlp(endnods(ii,1),3); %% 将末端节点的负荷电流赋给所连分支的分支电流
          Sendnod=Ibr(endnods(ii,1),1); %% Sendnod为之路的送端节点编号，它随之路的不同而变化的
          I=Ibr(endnods(ii,1),3);  %% 定义临时支路电流，它也随之路的不同而变化的
          k=0;
          kk=0;
          while kk<=Rower
                kk=kk+1;
                for jj=1:fsize
                   %% if Ibr(Sendnod,1)==forknods(jj)
                    if Sendnod==forknods(jj)
                       k=1;  %% 如果支路送端节点Sendnod是分叉节点的话，则赋给k=1,并退出本层循环体
                       break
                    end
                end
                if k==1
                   break   %% 如果k等于1,则表示支路的送端节点为分叉节点,退出本层循环体
                end
                %% 寻找受端节点是节点Sendnod的支路
                if Ibr(kk,2)==Sendnod
                   Ibr(kk,3)=I+Inlp(kk,3); %% 受端节点是节点Sendnod的支路的电流=送端节点是Sendnod的支路的电流+受端节点Sendnod处的负荷电流
                   Sendnod=Ibr(kk,1); %% 更新送端节点编号Sendnod为新支路的送端节点编号
                   I=Ibr(kk,3); %% 更新支路电流为新支路的支路电流
                   kk=0;
                end
                %% 寻找受端节点是节点Sendnod的支路
          end
      end

%% 由于在节点编号时有意将分叉点由小到大排列，由大的分叉点向小的分叉点聚拢，最后聚拢到一条支路上

      for n=1:fsize1             %% 交叉点由大到小循环
          Sendnod=fork1(n);
          I=0;
          for m=1:Rower
              if Ibr(m,1)==Sendnod  %% 寻找送端节点是交叉节点的支路
                 I=I+Ibr(m,3); %% 计算从交叉点流向其它分支的的总的电流，不包括节点Sendnod的负荷电流
              end
          end
          k=0;
          kk=0;
          while kk<Rower
                kk=kk+1;
                if Ibr(kk,2)==Sendnod  
                   Ibr(kk,3)=I+Inlp(kk,3); %% 计算受端节点为Sendnod的支路的电流 
                   Sendnod=Ibr(kk,1);
                   kk=0;
                   for nn=1:fsize1
                       if Sendnod==fork1(nn)
                          k=1; %% 如果受端节点为Sendnod的支路的送端节点编号是交叉点，则退出
                          break
                       end
                   end
                end
                if k==1
                   break
                end
          end
      end
%% 利用最终计算所得到的节点电压值重新计算各分支电流
%% 利用最终计算所得到的节点电压值重新计算各分支电流

U(:,1:2)=Unods(:,1:2);
U(:,3)=abs(Unods(:,3));
U(:,4)=angle(Unods(:,3));
fork1

%% 计算各支路的功率损耗
%% 计算各支路的功率损耗
IIbr=(Ibr(:,3).*conj(Ibr(:,3)));
Sloss=IIbr.*Zbr*Sbse*10^6; %% 单位为W
%% 计算各支路的功率损耗
%% 计算各支路的功率损耗
t2=clock;
t=t2-t1;
costime=t;
return