Symulacja rezystancji zastępczej

[G2+G4 -G2-G4   ][V1] [I]

[-G2-G4 G2+G4+G6][V2]=[0]

[-1 G12] [G11*E]

[0  G22]=[G21*E]

  PRouteItem=^TRouteItem;

  TRouteItem=record

            NodeNum: Integer;

            Element: PCircuitElement;

            Next: array[0..3] of PRouteItem;   //0 tworzy listę; 1-3 strukturę

         end;

procedure NumRouteNodes(const StartPoint, PrevPoint: PRouteItem; CurrNum: Integer=0; const ForceNum: Boolean=False);

var

   i: Byte;

   Zero: Boolean;

begin

   if (StartPoint^.NodeNum>=0) and not ForceNum then Exit;

   StartPoint^.NodeNum:=CurrNum;

   Zero:=(StartPoint^.Element^.CircuitElement.SimulationResult.X=0);

   if not Zero then CurrNum:=GetFirstFreeNodeNumOnRoute; //zwraca wartość jeszcze niewystępującą w strukturze

   for i:=1 to 3 do

      if (StartPoint^.Next[i]<>nil) and (StartPoint^.Next[i]<>PrevPoint) then //PrevPoint zapobiega cofnięciu się

         NumRouteNodes(StartPoint^.Next[i],StartPoint,CurrNum,Zero)

end;

type



PBranch=^TBranch;



PKnot:^TKnot;



TBranch=   record

      X:real; //(complex?)

      ToKnot:integer;

      Next:PBranch;

   end;



TKnot=   record   

      KnotNum:integer;

      Branches:PBranch;

      Next:PKnot

   end;

type



PBranch=^TBranch;



PKnot:^TKnot;



TBranch=record

      X:real; //(complex?, moze jeszcze zrodlo)

      ToKnot:integer;

      FromKnot:integer;

      Next:PBranch;

      Prev:PBranch;

      NextLin:PBranch;   //liniowa lista wszystkich galezi zaczyna się od BranchesStart

      PrevLin:PBranch;

      BranchNum:integer;

      test1,test2:boolean;

   end;



TKnot=   record   

      KnotNum:integer;

      Branches:PBranch;

      BranchesL:PBranch;       //do wskazania ostatniej galezi

      Next:PKnot;

      Prev:PKnot;

   end;



var 

   BranchesStart:PBranch=nil;

   BranchesLast:PBranch=nil;

   KnotsStart:PKnot=nil;

   KnotsLast:PKnot=nil;

CurrentBranch := BranchesStart^;

NumRenumKnots:=0;



while not CurrentBranch=nil do

  begin

  if CurrentBranch.X=0 then    //będzie co zaznaczać

    begin

    inc(NumRenumKnots);   //o jeden węzeł typu From więcej na listę

    V[NumRenumKnots,1]:=CurrentBranch.FromKnot;

    V[NumRenumKnots,1]:=CurrentBranch.ToKnot;

    end;

  CurrentBranch := CurrentBranch.NextLin^;   //do następnego elementu na liście wszystkich elementów

  end;



//mamy tablicę par węzłów do połączenia





if NumRenumKnots>0 then 

  begin

  for k:=1 to NumRenumKnots do

    if (V[k,1]>V[k,2]) then swap (V[k,1]>V[k,2]);

  sort_V1;   //sortowanie tablicy V po 1 kolumnie

  for k:=1 to NumRenumKnots do

    for m:=k+1 to NumRenumKnots do

      if (V[m,1]=V[k,2]) then V[m,1]:=V[k,1];   //w lewej kolumnie zostają tylko te numery węzłów które nie będą wykreślone z sieci

// teraz można uporządkować

  sort_V2;   //sortowanie tablicy V po 2 kolumnie

  sort_V1;   //sortowanie tablicy V po 1 kolumnie

// można pousuwać zapisy typu (7,7) {pojawia się gdy para wezłów będzie spięta dwiema impedancjami 0 "antyrównolegle"}

// można pousuwać powtarzające się zapisy identyczne np. z zapisów (3,9),(3,9),(3,9) wystarczy jeden {pojawia się gdy występują zera równoległe}

//  oczywiście wartość NumRenumKnots mogła zostać powyżej zmieniona, ale nie wyzerowana (podczas usuwania powtórzen)



// i na koniec można pozamieniać w gałęziach

  

  for k:=1 to NumRenumKnots do

    begin

    CurrentBranch := BranchesStart^;

    while not CurrentBranch=nil do

      begin

      if CurrentBranch.FromKnot=V[k,2] then CurrentBranch.FromKnot=V[k,1];   //tu zamieniamy na jeden węzeł, ten o niższym numerze

      if CurrentBranch.ToKnot=V[k,2] then CurrentBranch.ToKnot=V[k,1];   //tu też

      CurrentBranch := CurrentBranch.NextLin^;   //do następnego elementu na liście wszystkich elementów

      end;

    end;



//teraz w galeziach wystepuja tylko "wlasciwe" wezly

// pozostały do usunięcia "zle" wezly 





  for k:=1 to NumRenumKnots do

    begin

    CurrentKnot:=SzukajKnot(V[k,2]);   //znajdz wskaznik do wezla ktory bedziemy likwidowac

    if CurrentKnot.Prev=nil then    //wycinam wezeł z listy w tył

      KnotsStart:=CurrentKnot.Next

    else

      CurrentKnot.Prev^.Next:=CurrentKnot.Next;

    if CurrentKnot.Next=nil then    // i w przod

      KnotsLast:=CurrentKnot.Prev

    else

      CurrentKnot.Next^.Prev:=CurrentKnot.Prev;

    CurrentBranch:=SzukajKnot(V[k,1])^.Branches;   //teraz przesadzanie gałezi z wezla do wezla, znajdujemy gałęzie "własciwego" wezła

    while not CurrentBranch=nil do   

      CurrentBranch := CurrentBranch.Next^;   //do następnego elementu na liście galezi wezla

//stoimy na ostatnim

    CurrentBranch.Next:=CurrentKnot.Branches;   //doczepiamy listę galezi z likwidowaneo wezla (byc moze pusta)

    end;

//pozostalo usunac galezie o impedancji 0 zreszta zapetlone



  CurrentBranch := BranchesStart^;

  while not CurrentBranch=nil do

    begin

    if CurrentBranch.X=0 then    //teraz usuwamy

      begin

      if CurrentBranch.Prev=nil then    //wycinam wezeł z listy w tył (lista od wezla a nie globalna)

        SzukajKnot(CurrentBranch.FromKnot)^.Branches:=CurrentBranch.Next

      else

        CurrentBranch.Prev^.Next:=CurrentBranch.Next;

      if CurrentBranch.Next=nil then    // i w przod

        SzukajKnot(CurrentBranch.FromKnot)^.BranchesL:=CurrentBranch.Prev

      else

        CurrentBranch.Next^.Prev:=CurrentBranch.Prev;

      end;

    CurrentBranch := CurrentBranch.NextLin^;   //do następnego elementu na liście wszystkich elementów

    end;