METODA NEWTON-RAPHSON Teta(4,1)=0;

Un(4,1)=U(1,1);
% Pasul 1. Matricea Ynn a fost deja determinata anterior Pg(4,1)=0;
% Pasul 2. Initializarea procesului iterativ de calcul Qg(4,1)=0;
% Completarea tabelei Nod Pc(4,1)=0;
% Nodul 1 CON_MT: Nod PQ Qc(4,1)=0;
Tip_Nod(1,1)=0; Pimp(4,1)=0;
U(1,1)=1.000; Qimp(4,1)=0;
Teta(1,1)=0; Pcalc(4,1)=0;
Un(1,1)=U(1,1); Qcalc(4,1)=0;
Pg(1,1)=0; Uimp(4,1)=1.000;
Qg(1,1)=0; Qmin(4,1)=0;
Pc(1,1)=round(100*C1)/Sb; Qmax(4,1)=0;
Qc(1,1)=round(55*C1)/Sb; Stare_C(4,1)=0;
Pimp(1,1)=Pg(1,1)-Pc(1,1); Index_PQ(4,1)=0;
Qimp(1,1)=Qg(1,1)-Qc(1,1); % Stabileste valorile initiale pentru indexul iteratiei si dimensiunea
Pcalc(1,1)=0; Jac
Qcalc(1,1)=0; Iter=0;
Uimp(1,1)=0; Nr_Nod=4;
Qmin(1,1)=0; Nr_Nod_PQ=2;
Qmax(1,1)=0; Dim_Jac=Nr_Nod+Nr_Nod_PQ-1;
Stare_C(1,1)=0; Jac=zeros(Dim_Jac, Dim_Jac);
Index_PQ(1,1)=1; % Pasul 3. Calculul puterilor nodale
% Nodul 2 CET_IT: Nod PU while 1
Tip_Nod(2,1)=1; In=conj(Ynn*Un);
U(2,1)=1.020; Sn=Un.*In;
Teta(2,1)=0; Pcalc=real(Sn);
Un(2,1)=U(1,1); Qcalc=imag(Sn);
Pg(2,1)=round(90*C1)/Sb; % Pasul 4. Tratarea nodurilor generatoare
Qg(2,1)=0; if Iter > 2
Pc(2,1)=round(15*C1)/Sb; for i=1:Nr_nod-1
Qc(2,1)=round(8*C1)/Sb; if ((Tip_Nod(i,1)==1)&&(Stare_C(i,1)==0))
Pimp(2,1)=Pg(2,1)-Pc(2,1); Qi=Qcalc(i,1)-Qc(i,1);
Qimp(2,1)=0; if Qi < Qmin(i)
Pcalc(2,1)=0; Qimp(i,1)=Qmin(i);
Qcalc(2,1)=0; Stare_C(i,1)=-1;
Uimp(2,1)=1.020; end
Qmin(2,1)=0-Qc(2,1); if Qi > Qmax(i)
Qmax(2,1)=90/Sb-Qc(2,1); Qimp(i,1)=Qmax(i);
Stare_C(2,1)=0; Stare_C(i,1)=1;
Index_PQ(2,1)=0; end
% Nodul 3 CON_IT: Nod PQ end
Tip_Nod(3,1)=0; end
U(3,1)=1.000; end
Teta(3,1)=0; % Pasul 5. Calcularea abaterilor DP si DQ
Un(3,1)=U(1,1); Dpq(1:Nr_Nod-1,1)=Pimp(1:Nr_nod-1,1)-Pcalc(1:Nr_nod-1,1);
Pg(3,1)=0; Nr_Nod_PQ=0;
Qg(3,1)=0; for i=1:Nr_nod-1
Pc(3,1)=0; if (Tip_Nod(i,1)==0)
Qc(3,1)=0; Nr_Nod_PQ=Nr_Nod_PQ+1;
Pimp(3,1)=Pg(3,1)-Pc(3,1); Dpq(Nr_Nod-1+Nr_Nod_PQ,1)=Qimp(i,1)-Qcalc(i,1);
Qimp(3,1)=Qg(3,1)-Qc(3,1); Index_PQ(i,1)=Nr_Nod_PQ;
Pcalc(3,1)=0; end
Qcalc(3,1)=0; if (Tip_Nod(i,1)==1)&&(Stare_C(i,1)~=0)
Uimp(3,1)=0; Nr_Nod_PQ=Nr_Nod_PQ+1;
Qmin(3,1)=0; Dpq(Nr_Nod-1+Nr_Nod_PQ,1)=Qimp(i,1)-Qcalc(i,1);
Qmax(3,1)=0; Index_PQ(i,1)=Nr_Nod_PQ;
Stare_C(3,1)=0; end
Index_PQ(3,1)=2; if (Tip_Nod(i,1)==1)&&(Stare_C(i,1)==0)
% Nodul 4 SEN: Nod echilibru Index_PQ(i,1)=0;
Tip_Nod(4,1)=-1; end
U(4,1)=1.000; end
 Dpq_Max=max(abs(Dpq)); Index_Tk=k;
% Pasul 6. Efectuarea testului de convergenta Gik=real(Ynn(i,k));
if Iter > 2 Bik=imag(Ynn(i,k));
if (Dpq_Max<=Eps) Ui=U(i,1);
Temp=sprintf('Regimul a convers in %i iteratii', Iter); Uk=U(k,1);
disp(Temp); Tik=Teta(i,1)-Teta(k,1);
break; Jac(Index_Pi,Index_Tk)=Ui*Uk*(Gik*sin(Tik)-
end Bik*cos(Tik));
if Iter > 10 Jac(Index_Qi,Index_Tk)=-
disp('Regim divergent'); (Ui*Uk*(Gik*cos(Tik)+Bik*sin(Tik)));
break; end
end else
end if Index_PQ(k)~=0
Iter=Iter+1; Index_Pi=i;
% Pasul 7. Formarea matricei Jac. Calculul submatricelor Index_Tk=k;
H,K,L,M. Index_Uk=Nr_Nod-1+Index_PQ(k);
% Initializarea matricei Jac Gik=real(Ynn(i,k));
clear Jac; Bik=imag(Ynn(i,k));
Jac=zeros(Nr_Nod-1+Nr_Nod_PQ,Nr_Nod-1+Nr_Nod_PQ); Ui=U(i,1);
for i=1:Nr_Nod-1 Uk=U(k,1);
for k=1:Nr_Nod-1 Tik=Teta(i,1)-Teta(k,1);
if i==k Jac(Index_Pi,Index_Tk)=Ui*Uk*(Gik*sin(Tik)-
Gii=real(Ynn(i,i)); Bik*cos(Tik));
Bii=imag(Ynn(i,i));
Ui=U(i,1); Jac(Index_Pi,Index_Uk)=Ui*Uk*(Gik*cos(Tik)+Bik*sin(Tik));
Pi=Pcalc(i,1); else
Qi=Qcalc(i,1)-Qc(i,1); Index_Pi=i;
Index_Pi=i; Index_Tk=k;
Index_Ti=Index_Pi; Gik=real(Ynn(i,k));
if Index_PQ(i,1)~=0 Bik=imag(Ynn(i,k));
Index_Qi=Nr_Nod-1+Index_PQ(i); Ui=U(i,1);
Index_Ui=Index_Qi; Uk=U(k,1);
Jac(Index_Pi,Index_Ti)=-Bii*Ui^2-Qi; Tik=Teta(i,1)-Teta(k,1)
Jac(Index_Pi,Index_Ui)= Gii*Ui^2+Pi; Jac(Index_Pi,Index_Tk)=Ui*Uk*(Gik*sin(Tik)-
Jac(Index_Qi,Index_Ti)=-Gii*Ui^2+Pi; Bik*cos(Tik));
Jac(Index_Qi,Index_Ui)=-Bii*Ui^2+Qi; end
else end
Jac(Index_Pi,Index_Pi)=-Bii*Ui^2-Qi; end
end end
else end
if Index_PQ(i)~=0 % Pasul 8. Calcularea corectiilor DT si DU
if Index_PQ(k)~=0 D_TU=inv(Jac)*Dpq;
Index_Pi=i; % Pasul 9. Determinarea unei noi solutii
Index_Qi=Nr_Nod-1+Index_PQ(i); for i=1:Nr_Nod-1
Index_Tk=k; Teta(i,1)=Teta(i,1)+D_TU(i,1);
Index_Uk=Nr_Nod-1+Index_PQ(k); if Tip_Nod(i,1)==0
Gik=real(Ynn(i,k)); Index_Ui=Nr_Nod-1+Index_PQ(i);
Bik=imag(Ynn(i,k)); U(i,1)=U(i,1)*(1+D_TU(Index_Ui));
Ui=U(i,1); end
Uk=U(k,1); if (Tip_Nod(i,1)==1&&Index_PQ(i)~=0)
Tik=Teta(i,1)-Teta(k,1); Index_Ui=Nr_Nod-1+Index_PQ(i);
Jac(Index_Pi,Index_Tk)=Ui*Uk*(Gik*sin(Tik)- U(i,1)=U(i,1)*(1+D_TU(Index_Ui));
Bik*cos(Tik)); if (Stare_C(i,1)==-1)&&(U(i,1)<Uimp(i,1))
Stare_C(i,1)=0;
Jac(Index_Pi,Index_Uk)=Ui*Uk*(Gik*cos(Tik)+Bik*sin(Tik)); U(i,1)=Uimp(i,1);
Jac(Index_Qi,Index_Tk)=- end
(Ui*Uk*(Gik*cos(Tik)+Bik*sin(Tik))); if (Stare_C(i,1)==1)&&(U(i,1)>Uimp(i,1))
Jac(Index_Qi,Index_Uk)=Ui*Uk*(Gik*sin(Tik)- Stare_C(i,1)=0;
Bik*cos(Tik)); U(i,1)=Uimp(i,1);
else end
Index_Pi=i; end
Index_Qi=Nr_Nod-1+Index_PQ(i); end
 for i=1:Nr_Nod-1 yik0=(1/2).*(Pblinii(:,1).*Plinii(:,2));
Un(i,1)=U(i,1)*(cos(Teta(i,1))+j*sin(Teta(i,1))); SizeL=size(Date_Linii,1);
end SizeT=size(Date_Trafo,1);
% Pasul 10. Stabilirea p = p + 1 Cuad=zeros(sum(Date_Linii(:,10))+sum(Date_Trafo(:,12
end )),7);
% Rezultatele regimului permanent C1=0;
Rez=zeros(4,4); for j=1:SizeL
for i=1:4 for i=1:Date_Linii(j,10)
Rez(i,1)=U(i,1); C1=C1+1;
Rez(i,2)=Teta(i,1); Cuad(C1,1:7)=[Date_Linii(j, 1), Date_Linii(j, 2),
Rez(i,3)=Pcalc(i,1); yik(j,1), yik0(j,1), yik0(j,1), 1, Starelinii(C1)];
Rez(i,4)=Qcalc(i,1); end
Rez(i,5)=Tip_Nod(i,1); end
Rez(i,6)=Stare_C(i,1); %Parametrii transformatoarelor
Rez(i,7)=Index_PQ(i,1); RZ=[Date_Trafo(:,8).*(Date_Trafo(:,4)./Date_Trafo(:,3)).^
end 2./1000 ,
Rez_NR=Rez (Date_Trafo(:,9).*Date_Trafo(:,4).^2)./Date_Trafo(:,3)./1
00];
METODA DECUPLATA RAPIDA GY=[Date_Trafo(:,6)./Date_Trafo(:,4).^2./1000 ,
(Date_Trafo(:,7).*Date_Trafo(:,3))./Date_Trafo(:,4).^2./1
eps=0.0001; 00];
N=5; Ptransf=[complex(RZ(:,1), sqrt((RZ(:,2).^2-RZ(:,1).^2))) ,
C1=(1+(-1)^N*0.01*N); conj(complex(GY(:,1), sqrt((GY(:,2).^2-GY(:,1).^2))))];
Sb=100; Pbtransf=[Date_Noduri(Date_Trafo(:,1),2).^2./Sb
% Generatoare [ID,Nr,Sn, Pn, Un, Xd, X'd, Tst ] ,Sb./Date_Noduri(Date_Trafo(:,1),2).^2];
Generatoare = [1, 2, 75, 60, 10.5, 165.7, 30.9, 6.65]; %Pbtransf=[Date_Trafo(:,4).^2./Sb
% Linii [In,Out,Lungime, r0, x0, g0, b0, ,Sb./Date_Trafo(:,4).^2];
Imax,UM,Nr.] %Matricea de cuadripoli cu transformatoare
Date_Linii = [2, 4, round(60*(1+(-1)^N*0.01*N)), 0.12, ytik=Pbtransf(:,1)./Ptransf(:,1);
0.396, 0, 2.872/10^6, 420, 1, 2; ytik0=(Pbtransf(:,1).*Ptransf(:,2));
2, 3, round(50*(1-(-1)^N*0.01*N)), 0.16, 0.410, Nik=Date_Trafo(:,4)./(Date_Trafo(:,5).*(1.+Date_Trafo(:,
0, 2.728/10^6, 420, 1, 1; 11).*Date_Trafo(:,10)./100)).*Date_Noduri(Date_Trafo(:,
4, 3, round(55*(1-(-1)^N*0.01*N)), 0.12, 0.396, 2),2)./Date_Noduri(Date_Trafo(:,1),2);
0, 2.872/10^6, 420, 1, 2]; SizeL=C1;
% Transf [In,Out,Sn, Unf, Unr0,P0, i0, Psc, usc, for j=1:SizeT
Plot,Reg,Nr] for i=1:Date_Trafo(j,12)
Date_Trafo = [1, 3, 80, 10.5, 116, 67, 0.71, 304, 11.29, C1=C1+1;
0, 0, 2; Cuad(C1,1:7)=[Date_Trafo(j, 1), Date_Trafo(j, 2),
1, 3, 63, 22.0, 110, 60, 0.90, 260, 12.00, 0, ytik(j,1), 0, ytik0(j,1), Nik(j,1), Staretransf(C1-SizeL)];
1.78, 2]; end
% Noduri ord. [Tip,Un, Pg, Qg, Pc, Qc, end
Uimp, Qmin,Qmax] %Matricea admitantelor nodale
% 1-generare si echilibru, 0-consum SizeT=size(Date_Noduri,1); %Variabila ce contine
Date_Noduri = [0, 20, 0, 0, numarul de noduri
round(100*C1),round(55*C1),0, 0, 0; MatAdm=zeros(SizeT,SizeT);
1, 110, round(90*C1), 0, round(15*C1), for j=1:size(Cuad,1)
round(8*C1), 1.02*110, 0, 90; if(Cuad(j,7)==1)
0, 110, 0, 0, 0, 0, 0, 0,
0; MatAdm(Cuad(j,2),Cuad(j,1))=MatAdm(Cuad(j,2),Cuad(j,
1, 110, 0, 0, 0, 0, 110, 1))-Cuad(j,6)*Cuad(j,3);
0, 0];
%Starea MatAdm(Cuad(j,1),Cuad(j,2))=MatAdm(Cuad(j,2),Cuad(j,
Starelinii = [1, 1, 1, 1, 1]; 1));
Staretransf = [0,0,1,1];
%Parametrii liniilor electrice MatAdm(Cuad(j,1),Cuad(j,1))=MatAdm(Cuad(j,1),Cuad(j,
Plinii=[complex(Date_Linii(:,4),Date_Linii(:,5)).*Date_Lini 1))+(Cuad(j,3)+Cuad(j,4));
i(:,3),(complex(Date_Linii(:,6),Date_Linii(:,7)).*Date_Linii(
:,3))]; MatAdm(Cuad(j,2),Cuad(j,2))=MatAdm(Cuad(j,2),Cuad(j,
Pblinii=[(Date_Noduri(Date_Linii(:,1),2).^2./Sb) 2))+(Cuad(j,6)^2)*(Cuad(j,3)+Cuad(j,5));
,(Sb./Date_Noduri(Date_Linii(:,1),2).^2)]; end
%Matricea de cuadripoli cu linii end
yik=Pblinii(:,1)./Plinii(:,1); MatAdm;
% Initializarea tabelei Nod Nod(j,1)=0;
% Nod = [Tip, U, Teta, Un, Pg, Qg, Pc, Qc, Pimp, Qimp, C1=C1+1;
Pcalc, Qcalc, Qmin, Qmax, Uimp, Stare_C, Ind_Pq Nod(j,17)=C1;
Nod = [Date_Noduri(:,1), Nod(j,10)=Nod(j,14);
Date_Noduri(:,7)./Date_Noduri(:,2), Date_Noduri(:,1).*0, Nod(j,16)=-1;
... end
Date_Noduri(:,2)./Date_Noduri(:,2), end
Date_Noduri(:,3)./Sb, Date_Noduri(:,4)./Sb, %Crearea matricei B"=B2
Date_Noduri(:,5)./Sb, Date_Noduri(:,6)./Sb, ... if(C1~=C1ant)
Date_Noduri(:,3)./Sb-Date_Noduri(:,5)./Sb, C1ant=C1;
Date_Noduri(:,4)-Date_Noduri(:,6)./Sb, B2=zeros(C1,C1);
Date_Noduri(:,1).*0./Sb, ... for j=1:SizeT-1
Date_Noduri(:,1).*0./Sb, Date_Noduri(:,8)./Sb, if (Nod(j,1)==0)
Date_Noduri(:,9)./Sb,Date_Noduri(:,7)./Date_Noduri(:,2), for i=j:SizeT-1
... if (Nod(i,1)==0)
Date_Noduri(:,1).*0, Date_Noduri(:,1).*0]; B2(Nod(j,17), Nod(i,17))=-
C1=0; %Variabila de indexare a nodurilor PQ imag(MatAdm(j,i));
% Corectii pentru nodurile de tip PU in tabela Nod B2(Nod(i,17), Nod(j,17))=-
for j=1:SizeT-1 imag(MatAdm(i,j));
if (Nod(j,1)==0) end
C1=C1+1; end
Nod(j,17)=Nod(j,17)+C1; end
Nod(j,2)=1; end
end end
end %Abateri ale P
% Variabile si constante utile Abateri(1:SizeT-1,1)=(Nod(1:SizeT-1,9)-
Abateri = ones(SizeT+C1-1,1); Puteri(1:SizeT-1,1))./Nod(1:SizeT-1,2);
C1ant=0; if max(abs(Abateri))>=eps
Iter=-1; for j=1:SizeT-1
%Formarea matricelor B'=B1 if(Nod(j,1)==0)
B1=-imag(MatAdm(1:3,1:3)); %Abateri ale Q
%Metoda decuplata rapida Abateri(Nod(j,17)+SizeT-1,1)=(Nod(j,10)-
while (max(abs(Abateri))>=eps && Iter<11) Puteri(j,2))/Nod(j,2);
Iter=Iter+1; end
%Calculul puterilor nodale end
In=MatAdm*Nod(:,4); Du=B2\Abateri(SizeT:SizeT-1+C1,1);
Sn=Nod(:,4).*conj(In); for j=1:SizeT-1
Puteri(1:4,1)=real(Sn); if(Nod(j,1)==0)
Puteri(1:4,2)=imag(Sn); Nod(j,2)=Nod(j,2)+Du(Nod(j,17),1);
%Abateri ale P end
Abateri(1:SizeT-1,1)=(Nod(1:SizeT-1,9)- if(Nod(j,1)==0 && Nod(j,17) &&
Puteri(1:SizeT-1,1))./Nod(1:SizeT-1,2); Nod(j,16)*(Nod(j,1)-Nod(j,15))>0)
Dteta=(B1\Abateri(1:SizeT-1,1)); Nod(j,16)=0;
Nod(1:SizeT-1,3)=Nod(1:SizeT-1,3)+(Dteta); Nod(j,2)=Nod(j,15);
C1=C1-1;
Nod(:,4)=Nod(:,2).*complex((cos(Nod(:,3))),sin(Nod(:,3)) end
); %Fara asta, cresc iteratiile
%Recalculul puterilor nodale Nod(j,4)=Nod(j,2)*complex((cos(Nod(j,3))),sin(Nod(j,3)));
In=MatAdm*Nod(:,4); end
Sn=Nod(:,4).*conj(In); end
Puteri(1:4,1)=real(Sn); end
Puteri(1:4,2)=imag(Sn); if (Iter<11)
%Tratarea nodurilor generatoare Temp=sprintf('Regimul a convers in %i iteratii', Iter);
if(Iter>2 && Nod(j,1)) disp(Temp);
if(Puteri(j,2) < Nod(j,13)) %Rezultate regim permanent
Nod(j,1)=0; %Rez=(U, Teta, Pcalc, Qcalc, Tip_Nod,
C1=C1+1; Stare_C, Index_PQ
Nod(j,17)=C1; Rez=[Nod(:,2), Nod(:,3), Nod(:,11), Nod(:,12),
Nod(j,10)=Nod(j,13); Nod(:,1), Nod(:,16), Nod(:,17)]
Nod(j,16)=1; else
end disp('Regim divergent');
if(Puteri(j,2) > Nod(j,14)) end