public LoadFlowResult GetLoadFlow(long gid)
{
LoadFlowResult result = null;
loadFlow.TryGetValue(gid, out result);
return(result);
}
double CalculateVoltageForACLineSegment(Node node, Dictionary <long, LoadFlowResult> lf, Dictionary <long, Complex> currents)
{
Complex current;
if (!currents.TryGetValue(node.IO.GID, out current))
{
return(double.MaxValue);
}
ACLineSegment segment = node.IO as ACLineSegment;
List <Node> nodes = new List <Node>(2);
for (int i = node.AdjacentOffset; i < node.AdjacentOffset + node.AdjacentCount; ++i)
{
Node n = adjacency[i];
if (!nodes.Contains(n) && ModelCodeHelper.GetTypeFromGID(n.IO.GID) == DMSType.ConnectivityNode)
{
nodes.Add(n);
}
}
if (nodes.Count != 2)
{
return(0);
}
LoadFlowResult lfr1;
if (!lf.TryGetValue(nodes[0].IO.GID, out lfr1))
{
return(0);
}
Complex u1 = new Complex(lfr1.Get(LoadFlowResultType.UR), lfr1.Get(LoadFlowResultType.UI));
Complex u2 = u1.Subtract(new Complex(segment.PerLengthPhaseResistance * segment.Length, segment.PerLengthPhaseReactance * segment.Length).Multiply(current));
LoadFlowResult lfr2;
double relDelta = double.MaxValue;
if (!lf.TryGetValue(nodes[1].IO.GID, out lfr2))
{
lfr2 = new LoadFlowResult();
lf[nodes[1].IO.GID] = lfr2;
}
else
{
relDelta = GetVoltageRelativeDifference(new Complex(lfr2.Get(LoadFlowResultType.UR), lfr2.Get(LoadFlowResultType.UI)), u2);
}
lfr2.Remove(LoadFlowResultType.UR);
lfr2.Remove(LoadFlowResultType.UI);
lfr2.Add(new LoadFlowResultItem(u2.X, LoadFlowResultType.UR));
lfr2.Add(new LoadFlowResultItem(u2.Y, LoadFlowResultType.UI));
return(relDelta);
}
Complex CalculateCurrentForACLineSegment(Node node, IEnumerable <Complex> childCurrents, Dictionary <long, LoadFlowResult> lf)
{
Complex result = CalculateCurrentDefault(node, childCurrents, lf);
LoadFlowResult lfr;
if (!lf.TryGetValue(node.IO.GID, out lfr))
{
lfr = new LoadFlowResult();
lf[node.IO.GID] = lfr;
}
lfr.Remove(LoadFlowResultType.IR);
lfr.Remove(LoadFlowResultType.II);
lfr.Add(new LoadFlowResultItem(result.X, LoadFlowResultType.IR));
lfr.Add(new LoadFlowResultItem(result.Y, LoadFlowResultType.II));
List <Node> nodes = new List <Node>(2);
for (int i = node.AdjacentOffset; i < node.AdjacentOffset + node.AdjacentCount; ++i)
{
Node n = adjacency[i];
if (!nodes.Contains(n) && ModelCodeHelper.GetTypeFromGID(n.IO.GID) == DMSType.ConnectivityNode)
{
nodes.Add(n);
}
}
if (nodes.Count != 2)
{
return(result);
}
LoadFlowResult lfr1;
LoadFlowResult lfr2;
if (!lf.TryGetValue(nodes[0].IO.GID, out lfr1) || !lf.TryGetValue(nodes[1].IO.GID, out lfr2))
{
return(result);
}
ACLineSegment segment = node.IO as ACLineSegment;
Complex u1 = new Complex(lfr1.Get(LoadFlowResultType.UR), lfr1.Get(LoadFlowResultType.UI));
Complex u2 = new Complex(lfr2.Get(LoadFlowResultType.UR), lfr2.Get(LoadFlowResultType.UI));
Complex s = u1.Subtract(u2).Multiply(new Complex(result.X, -result.Y));
lfr.Remove(LoadFlowResultType.SR);
lfr.Remove(LoadFlowResultType.SI);
lfr.Add(new LoadFlowResultItem(s.X, LoadFlowResultType.SR));
lfr.Add(new LoadFlowResultItem(s.Y, LoadFlowResultType.SI));
return(result);
}
double CalculateVoltageForSwitch(Node node, Dictionary <long, LoadFlowResult> lf, Dictionary <long, Complex> currents)
{
if (!currents.ContainsKey(node.IO.GID))
{
return(double.MaxValue);
}
List <Node> nodes = new List <Node>(2);
for (int i = node.AdjacentOffset; i < node.AdjacentOffset + node.AdjacentCount; ++i)
{
Node n = adjacency[i];
if (!nodes.Contains(n) && ModelCodeHelper.GetTypeFromGID(n.IO.GID) == DMSType.ConnectivityNode)
{
nodes.Add(n);
}
}
if (nodes.Count != 2)
{
return(0);
}
LoadFlowResult lfr1;
if (!lf.TryGetValue(nodes[0].IO.GID, out lfr1))
{
return(0);
}
Complex u1 = new Complex(lfr1.Get(LoadFlowResultType.UR), lfr1.Get(LoadFlowResultType.UI));
Complex u2 = GetSwitchState(node.IO as Switch) ? new Complex(0, 0) : u1;
LoadFlowResult lfr2;
double relDelta = double.MaxValue;
if (!lf.TryGetValue(nodes[1].IO.GID, out lfr2))
{
lfr2 = new LoadFlowResult();
lf[nodes[1].IO.GID] = lfr2;
}
else
{
relDelta = GetVoltageRelativeDifference(new Complex(lfr2.Get(LoadFlowResultType.UR), lfr2.Get(LoadFlowResultType.UI)), u2);
}
lfr2.Remove(LoadFlowResultType.UR);
lfr2.Remove(LoadFlowResultType.UI);
lfr2.Add(new LoadFlowResultItem(u2.X, LoadFlowResultType.UR));
lfr2.Add(new LoadFlowResultItem(u2.Y, LoadFlowResultType.UI));
return(relDelta);
}
double CalculateVoltageForTransformerWinding(Node node, Dictionary <long, LoadFlowResult> lf, Dictionary <long, Complex> currents)
{
TransformerWinding tw = node.IO as TransformerWinding;
if (IsTransformerWindingPrimary(tw))
{
return(0);
}
if (!currents.ContainsKey(node.IO.GID))
{
return(double.MaxValue);
}
PowerTransformer pw = Get(tw.PowerTransformer) as PowerTransformer;
TransformerWinding tw1 = null;
for (int i = 0; i < pw.TransformerWindings.Count; ++i)
{
long twGid = pw.TransformerWindings[i];
if (twGid != tw.GID)
{
tw1 = Get(twGid) as TransformerWinding;
break;
}
}
long node1Gid = (Get(tw1.Terminals[0]) as Terminal).ConnectivityNode;
long node2Gid = (Get(tw.Terminals[0]) as Terminal).ConnectivityNode;
LoadFlowResult lfr1;
if (!lf.TryGetValue(node1Gid, out lfr1))
{
return(0);
}
Complex u1 = new Complex(lfr1.Get(LoadFlowResultType.UR), lfr1.Get(LoadFlowResultType.UI));
Complex u2 = u1.Scale(1.0 / GetPowerTransformerRatio(pw));
LoadFlowResult lfr2;
double relDelta = double.MaxValue;
if (!lf.TryGetValue(node2Gid, out lfr2))
{
lfr2 = new LoadFlowResult();
lf[node2Gid] = lfr2;
}
else
{
relDelta = GetVoltageRelativeDifference(new Complex(lfr2.Get(LoadFlowResultType.UR), lfr2.Get(LoadFlowResultType.UI)), u2);
}
lfr2.Remove(LoadFlowResultType.UR);
lfr2.Remove(LoadFlowResultType.UI);
lfr2.Add(new LoadFlowResultItem(u2.X, LoadFlowResultType.UR));
lfr2.Add(new LoadFlowResultItem(u2.Y, LoadFlowResultType.UI));
return(relDelta);
}
void CalculateLoadFlowForSubGraph(Node source, List <KeyValuePair <long, LoadFlowResult> > result)
{
Dictionary <long, LoadFlowResult> lf = new Dictionary <long, LoadFlowResult>();
EnergySource es = source.IO as EnergySource;
if (es == null)
{
return;
}
Complex u1 = GetVoltageFromEnergySource(es);
if (u1.IsNaN())
{
return;
}
Dictionary <long, Complex> currents = new Dictionary <long, Complex>();
for (int iteration = 0; iteration < maxIterations; ++iteration)
{
double maxVoltageRelativeDelta = 0;
Stack <Triple <Node, int, List <Complex> > > stack = new Stack <Triple <Node, int, List <Complex> > >();
stack.Push(new Triple <Node, int, List <Complex> >(source, 0, new List <Complex>(source.AdjacentCount - 1)));
HashSet <long> visited = new HashSet <long>();
while (stack.Count > 0)
{
Triple <Node, int, List <Complex> > triple = stack.Pop();
Node node = triple.First;
int childrenPos = triple.Second;
Func <Node, IEnumerable <Complex>, Dictionary <long, LoadFlowResult>, Complex> currentFunction = CalculateCurrentDefault;
visited.Add(node.IO.GID);
DMSType type = ModelCodeHelper.GetTypeFromGID(node.IO.GID);
switch (type)
{
case DMSType.Recloser:
continue;
case DMSType.ConnectivityNode:
{
LoadFlowResult lfr;
if (!lf.TryGetValue(node.IO.GID, out lfr))
{
lfr = new LoadFlowResult();
lfr.Add(new LoadFlowResultItem(u1.X, LoadFlowResultType.UR));
lfr.Add(new LoadFlowResultItem(u1.Y, LoadFlowResultType.UI));
lf[node.IO.GID] = lfr;
}
}
break;
case DMSType.EnergyConsumer:
{
currentFunction = CalculateCurrentForEnergyConsumer;
LoadFlowResult lfr;
if (!lf.TryGetValue(node.IO.GID, out lfr))
{
Complex s = GetPowerForEnergyConsumer(node.IO as EnergyConsumer);
lfr = new LoadFlowResult();
lfr.Add(new LoadFlowResultItem(s.X, LoadFlowResultType.SR));
lfr.Add(new LoadFlowResultItem(s.Y, LoadFlowResultType.SI));
lf[node.IO.GID] = lfr;
}
}
break;
case DMSType.Breaker:
case DMSType.Disconnector:
{
currentFunction = CalculateCurrentForSwitch;
if (childrenPos == 0)
{
double maxDelta = CalculateVoltageForSwitch(node, lf, currents);
if (maxDelta > maxVoltageRelativeDelta)
{
maxVoltageRelativeDelta = maxDelta;
}
}
}
break;
case DMSType.DistributionGenerator:
{
currentFunction = CalculateCurrentForDistributionGenerator;
}
break;
case DMSType.TransformerWinding:
{
currentFunction = CalculateCurrentForTransformerWinding;
if (childrenPos == 0)
{
double maxDelta = CalculateVoltageForTransformerWinding(node, lf, currents);
if (maxDelta > maxVoltageRelativeDelta)
{
maxVoltageRelativeDelta = maxDelta;
}
}
}
break;
case DMSType.ACLineSegment:
{
currentFunction = CalculateCurrentForACLineSegment;
if (childrenPos == 0)
{
double maxDelta = CalculateVoltageForACLineSegment(node, lf, currents);
if (maxDelta > maxVoltageRelativeDelta)
{
maxVoltageRelativeDelta = maxDelta;
}
}
}
break;
}
Node childNode = null;
for (int i = node.AdjacentOffset + childrenPos; i < node.AdjacentOffset + node.AdjacentCount; ++i)
{
Node adjacentNode = adjacency[i];
if (adjacentNode == null || visited.Contains(adjacentNode.IO.GID))
{
continue;
}
childNode = adjacentNode;
break;
}
if (childNode != null)
{
stack.Push(new Triple <Node, int, List <Complex> >(node, childrenPos + 1, triple.Third));
stack.Push(new Triple <Node, int, List <Complex> >(childNode, 0, new List <Complex>(childNode.AdjacentCount - 1)));
continue;
}
if (stack.Count > 0)
{
Complex current = currentFunction(node, triple.Third, lf);
stack.Peek().Third.Add(current);
currents[node.IO.GID] = current;
}
}
if (maxVoltageRelativeDelta < voltageRelativeDelta)
{
break;
}
}
result.AddRange(lf);
}
public IEnumerable <LoadFlowResult> Get([FromRoute] int id)
{
//-------------Load Flow Algorithm---------------
//-----obliczenia wykonywane sa na jednostkach wzglednych
List <int> buses = new List <int>();
int N_bus; //liczba szyn/wezlow
int N_ser; //liczba elementow galeziowych
double Sb = 100; //MVA moc bazowa
double Ub = 60; //kV napiecie bazowe
double Zb = Math.Pow(Ub, 2) / Sb; //Ohm impedancja bazowa
double Yb = 1 / Zb; //admitancja bazowa
double Ib = Sb / (Math.Sqrt(3) * Ub) * 1000; //A - prad bazowy
//obliczenia wykonuj na danym projekcie
ExternalGrid[] extgrids = _context.ExternalGrids.Where(m => m.ProjectId == id).ToArray();
OverheadLine[] ovheads = _context.OverheadLines.Where(m => m.ProjectId == id).ToArray();
TwoPhaseTransformer[] twophasetrafo = _context.TwoPhaseTransformers.Where(m => m.ProjectId == id).ToArray();
Bus[] busbars = _context.Buses.Where(m => m.ProjectId == id).ToArray();
/*
* if (project == null)
* {
* return NotFound();
* }
*/
//Jesli nie istnieja tego typu elementy to oznacza sie numer szyny rowny 1 oraz wartosc zero w drugiej kolumnie.
int[] shunts = new int[] { 1, 0 }; //elementy poprzeczne
//int N_sh = 1; // liczba element�w poprzecznych
//pomocnicze tablice
List <int> Is = new List <int>(); //numery szyn poczatkowych
List <int> Js = new List <int>(); // numery szyn koncowych
List <string> Itype = new List <string>();
List <double> Pb = new List <double>();
List <double> Qb = new List <double>();
//Complex c1 = new Complex(1.2, 2.0);
//ilosc elementow podluznych
N_ser = ovheads.Count() + twophasetrafo.Count();
//okresl ilosc szyn
foreach (var row in extgrids)
{
if (!buses.Contains(row.NodeNo))
{
buses.Add(row.NodeNo);
}
Itype.Add(row.NodeType);
//obliczenia na podstawie jednostek wzglednych
Pb.Add((row.ActivePower.HasValue) ? row.ActivePower.Value / Sb : 0);
Qb.Add((row.ReactivePower.HasValue) ? row.ReactivePower.Value / Sb : 0);
}
foreach (var row in ovheads)
{
if (!buses.Contains(row.StartNodeNo))
{
buses.Add(row.StartNodeNo);
}
if (!buses.Contains(row.EndNodeNo))
{
buses.Add(row.EndNodeNo);
}
Is.Add(row.StartNodeNo);
Js.Add(row.EndNodeNo);
}
N_bus = buses.Count;
System.Diagnostics.Debug.WriteLine("BUS.COUNT: " + buses.Count);
System.Diagnostics.Debug.WriteLine("ExternalGrid.COUNT: " + _context.ExternalGrids.Count());
//uformuj macierz z elementami podluznymi - Series_pu
Complex[,] Series_pu = new Complex[N_ser, 5];
int irow = 0;
foreach (var row in ovheads)
{
Complex RX = new Complex(row.UnitaryResistance * row.Length, row.UnitaryReactance * row.Length);
Complex B = new Complex(0, row.UnitaryCapacitance * row.Length);
Series_pu[irow, 0] = row.StartNodeNo;
Series_pu[irow, 1] = row.EndNodeNo;
Series_pu[irow, 2] = RX / Zb;
Series_pu[irow, 3] = B / (Yb * Math.Pow(10, 6)); //przeliczenie z uS
Series_pu[irow, 4] = 1; //TUTAJ BEDA PRZEKLADNIE TRANSFORMATOROW
irow++;
}
foreach (var row in twophasetrafo)
{
Complex RX = new Complex((row.LoadLossesRated * row.HVVoltageRated * row.HVVoltageRated) / (1000 * row.ApparentPowerRated * row.ApparentPowerRated), row.ShortCircuitVoltage / 100); //zastanow sie jak wyliczac parametry transformatora
Complex B = new Complex(0, 0);
Series_pu[irow, 0] = row.HVNodeNo;
Series_pu[irow, 1] = row.LVNodeNo;
Series_pu[irow, 2] = RX / Zb;
Series_pu[irow, 3] = B / Yb;
irow++;
}
double?[] sigma = new double?[N_bus];
//uformuj macierz - buses
foreach (var row in extgrids)
{
sigma[row.NodeNo] = row.VoltageAngle; //row.ID-1
}
double[] U = new double[N_bus];
double[] Upu = new double[N_bus];
//uformuj macierz - U
foreach (var row in busbars)
{
Upu[row.NodeNo] = row.NominalVoltage / Ub; //row.ID-1
}
/*
* //wartosci napiec z bezwglednych na wzgledne
*
* for (int c = 0; c <= (U.Length-1); c++)
* {
* Upu[c] = U[c] / Ub;
* }
*/
double[] normalSigma = new double[N_bus];
for (int n = 0; n <= (N_bus - 1); n++)
{
normalSigma[n] = (sigma[n].HasValue) ? sigma[n].Value : 0; //przekonwertowanie double? na double
}
//uformuj macierz admitancyjna
Complex[,] Ybus = new Complex[N_bus, N_bus];
Ybus = formYmatrix(N_bus, N_ser, Is, Js, Series_pu, shunts);
//oblicz macierz Jacobiego
double[,] Jac = new double[N_bus + 1, N_bus + 1];
Jac = calcJacobiMatrix(N_bus, Ybus, Upu, normalSigma, Itype);
//odwroc macierz Jacobiego
double[,] JacInv = new double[Jac.GetLength(0), Jac.GetLength(1)];
JacInv = MatrixInverseFunc.Main(Jac);
int maxIter = 25; //maksymalna liczba iteracji
double lambda = 1; //acceleration coefficient. This coefficient takes values less than one and improves the convergence characteristics of the problem. The user may change the value of l to see its effect on the mismatch at the end of the iterations.
for (int i = 0; i <= (maxIter - 1); i++)
{
for (int m = 1; m <= (N_bus - 1); m++)
{
Upu[m] = Upu[m] + deltaV(m, N_bus, Itype, JacInv, Ybus, normalSigma, Upu, Pb, Qb) * lambda;
normalSigma[m] = normalSigma[m] + deltaSigma(m, N_bus, Itype, JacInv, Ybus, normalSigma, Upu, Pb, Qb) * lambda;
//System.Diagnostics.Debug.WriteLine("m " + m + "normalSigma[m]" + normalSigma[m]);
//System.Diagnostics.Debug.WriteLine("m " + m + "deltaSigma" + deltaSigma(m, N_bus, Itype, JacInv, Ybus, normalSigma, U, Pb, Qb));
}
}
//z wartosci wzglednych na bezwzgledne
for (int m = 0; m <= (Upu.Length - 1); m++)
{
U[m] = Upu[m] * Ub;
}
//obliczanie strat mocy na poszczególnych gałeziach
double[] Ploss = new double[N_bus];
Ploss = activePowerLoss(Upu, normalSigma, Series_pu, N_bus, Is, Js, Sb);
double[] Qloss = new double[N_bus];
Qloss = reactivePowerLoss(Upu, normalSigma, Series_pu, N_bus, Is, Js, Sb);
//prąd wpywajacy od wezla i i doplywajacy do wezla j
Complex[] IloadI = new Complex[N_bus];
IloadI = Iload_i(Upu, normalSigma, Series_pu, N_bus, Is, Js, Ib);
Complex[] IloadJ = new Complex[N_bus];
IloadJ = Iload_j(Upu, normalSigma, Series_pu, N_bus, Is, Js, Ib);
int[] busStart_I = new int[N_bus];
busStart_I = busStartI(N_bus, Is);
int[] busEnd_J = new int[N_bus];
busEnd_J = busEndJ(N_bus, Js);
//radian to degree
double[] normalSigmaDegrees = new double[N_bus];
for (int c = 0; c <= (normalSigma.Length - 1); c++)
{
normalSigmaDegrees[c] = normalSigma[c] * (180.0 / Math.PI);
}
var list = new LoadFlows();
list.Results = new List <LoadFlowResult>();
for (int z = 0; z <= (N_bus - 1); z++)
{
var a = new LoadFlowResult()
{
busNo = z, resultU = U[z], resultUpu = Upu[z], resultSigma = normalSigmaDegrees[z], resultPloss = Ploss[z], resultQloss = Qloss[z], resultIload_i = IloadI[z].Magnitude, resultIload_j = IloadJ[z].Magnitude, busNoStart = busStart_I[z], busNoEnd = busEnd_J[z]
};
list.Results.Add(a);
}
return(list.Results);
}
void RedrawLoadFlow()
{
if (!loadFlowChanged || topology == null)
{
return;
}
loadFlowChanged = false;
List <GraphicsText> loadFlows = new List <GraphicsText>();
for (int i = 0; i < elements.Count; ++i)
{
GraphicsElement element = elements[i];
if (element.IO == null)
{
continue;
}
LoadFlowResult lfResult = topology.GetLoadFlow(element.IO.GID);
if (lfResult == null)
{
continue;
}
switch (ModelCodeHelper.GetTypeFromGID(element.IO.GID))
{
case DMSType.ConnectivityNode:
{
double ur = lfResult.Get(LoadFlowResultType.UR);
double ui = lfResult.Get(LoadFlowResultType.UI);
if (double.IsNaN(ur) || double.IsNaN(ui))
{
break;
}
GraphicsText gtu = new GraphicsText(element.X + loadFlowXOffset, 0, GetLoadFlowItemText(ur, ui, "V"), Brushes.Black, Brushes.Transparent, element, loadFlowFontSize);
gtu.Y = element.Y - gtu.CalculateSize().Height / 2;
loadFlows.Add(gtu);
}
break;
case DMSType.ACLineSegment:
{
double ir = lfResult.Get(LoadFlowResultType.IR);
double ii = lfResult.Get(LoadFlowResultType.II);
double sr = lfResult.Get(LoadFlowResultType.SR);
double si = lfResult.Get(LoadFlowResultType.SI);
if (double.IsNaN(ir) || double.IsNaN(ii) || double.IsNaN(sr) || double.IsNaN(si))
{
break;
}
bool abnormalCurrent = ComplexLength(ir, ii) > ((ACLineSegment)element.IO).RatedCurrent;
GraphicsText gti = new GraphicsText(element.X + loadFlowXOffset, 0, GetLoadFlowItemText(ir, ii, "A"), abnormalCurrent ? Brushes.White : Brushes.Black, abnormalCurrent ? Brushes.DarkRed : Brushes.Transparent, element, loadFlowFontSize);
GraphicsText gts = new GraphicsText(element.X + loadFlowXOffset, 0, GetLoadFlowItemText(sr, si, "VA"), Brushes.Black, Brushes.Transparent, element, loadFlowFontSize);
Size gtiSize = gti.CalculateSize();
Size gtsSize = gts.CalculateSize();
gti.Y = element.Y - (gtiSize.Height + gtsSize.Height) / 2;
gts.Y = gti.Y + gtiSize.Height;
loadFlows.Add(gti);
loadFlows.Add(gts);
}
break;
case DMSType.EnergyConsumer:
{
double sr = lfResult.Get(LoadFlowResultType.SR);
double si = lfResult.Get(LoadFlowResultType.SI);
if (double.IsNaN(sr) || double.IsNaN(si))
{
break;
}
GraphicsText gts = new GraphicsText(0, element.Y + loadFlowYOffset, GetLoadFlowItemText(sr, si, "VA"), Brushes.Black, Brushes.Transparent, element, loadFlowFontSize);
gts.X = element.X - gts.CalculateSize().Width / 2;
loadFlows.Add(gts);
}
break;
}
}
this.loadFlows = loadFlows;
}
public IEnumerable <LoadFlowResult> Get()
{
//-------------Load Flow Algorithm---------------
List <int> buses = new List <int>();
int N_bus; //liczba szyn/w�z��w
int N_ser; //liczba element�w ga��ziowych
//Je�li nie istniej� tego typu elementy to oznacza si� numer szyny r�wny 1 oraz warto�� zero w drugiej kolumnie.
int[] shunts = new int[] { 1, 0 }; //elementy poprzeczne
//int N_sh = 1; // liczba element�w poprzecznych
//pomocnicze tablice
List <int> Is = new List <int>(); //numery szyn pocz�tkowych
List <int> Js = new List <int>(); // numery szyn ko�cowych
List <string> Itype = new List <string>();
List <double> Pb = new List <double>();
List <double> Qb = new List <double>();
//Complex c1 = new Complex(1.2, 2.0);
//ilo�� element�w pod�u�nych
N_ser = _context.OverheadLines.Count() + _context.TwoPhaseTransformers.Count();
//okre�l ilo�� szyn
foreach (var row in _context.ExternalGrids)
{
if (!buses.Contains(row.NodeNo))
{
buses.Add(row.NodeNo);
}
Itype.Add(row.NodeType);
//normalSigma[n] = (sigma[n].HasValue) ? sigma[n].Value : 0;
Pb.Add((row.ActivePower.HasValue) ? row.ActivePower.Value : 0);
Qb.Add((row.ReactivePower.HasValue) ? row.ReactivePower.Value : 0);
}
foreach (var row in _context.OverheadLines)
{
if (!buses.Contains(row.StartNodeNo))
{
buses.Add(row.StartNodeNo);
}
if (!buses.Contains(row.EndNodeNo))
{
buses.Add(row.EndNodeNo);
}
Is.Add(row.StartNodeNo);
Js.Add(row.EndNodeNo);
}
N_bus = buses.Count;
System.Diagnostics.Debug.WriteLine("BUS.COUNT: " + buses.Count);
System.Diagnostics.Debug.WriteLine("ExternalGrid.COUNT: " + _context.ExternalGrids.Count());
//uformuj macierz z elementami pod�u�nymi - series
Complex[,] Series = new Complex[N_ser, 5];
foreach (var row in _context.OverheadLines)
{
Complex RX = new Complex(row.UnitaryResistance * row.Length, row.UnitaryReactance * row.Length);
Complex B = new Complex(0, row.UnitaryCapacitance * row.Length);
Series[(row.ID - 1), 0] = row.StartNodeNo;
Series[(row.ID - 1), 1] = row.EndNodeNo;
Series[(row.ID - 1), 2] = RX;
Series[(row.ID - 1), 3] = B;
Series[(row.ID - 1), 4] = 1; //TUTAJ BED� PRZEK�ADNIE TRANSFORMATOROW
}
double[] U = new double[N_bus];
double?[] sigma = new double?[N_bus];
//uformuj macierz - buses
foreach (var row in _context.ExternalGrids)
{
// Buses[row.ID-1, 1] = row.NodeType;
sigma[row.ID - 1] = row.VoltageAngle;
}
double[] normalSigma = new double[N_bus];
for (int n = 0; n <= (N_bus - 1); n++)
{
normalSigma[n] = (sigma[n].HasValue) ? sigma[n].Value : 0; //przekonwertowanie double? na double
}
//sztucznie dodane napi�cia
U[0] = 60;
U[1] = 60;
U[2] = 60;
//uformuj macierz admitancyjn�
Complex[,] Ybus = new Complex[N_bus, N_bus];
Ybus = formYmatrix(N_bus, N_ser, Is, Js, Series, shunts);
//oblicz macierz Jacobiego
double[,] Jac = new double[N_bus + 1, N_bus + 1];
Jac = calcJacobiMatrix(N_bus, Ybus, U, normalSigma, Itype);
//odwr�� macierz Jacobiego
double[,] JacInv = new double[Jac.GetLength(0), Jac.GetLength(1)];
JacInv = MatrixInverseFunc.Main(Jac);
int maxIter = 12; //maksymalna liczba iteracji
double lambda = 1; //acceleration coefficient. This coefficient takes values less than one and improves the convergence characteristics of the problem. The user may change the value of l to see its effect on the mismatch at the end of the iterations.
for (int i = 0; i <= (maxIter - 1); i++)
{
for (int m = 1; m <= (N_bus - 1); m++)
{
U[m] = U[m] + deltaV(m, N_bus, Itype, JacInv, Ybus, normalSigma, U, Pb, Qb) * lambda;
normalSigma[m] = normalSigma[m] + deltaSigma(m, N_bus, Itype, JacInv, Ybus, normalSigma, U, Pb, Qb) * lambda;
//System.Diagnostics.Debug.WriteLine("m " + m + "normalSigma[m]" + normalSigma[m]);
//System.Diagnostics.Debug.WriteLine("m " + m + "deltaSigma" + deltaSigma(m, N_bus, Itype, JacInv, Ybus, normalSigma, U, Pb, Qb));
}
}
//radian to degree
for (int c = 0; c <= (normalSigma.Length - 1); c++)
{
normalSigma[c] = normalSigma[c] * (180.0 / Math.PI);
}
// var viewModel = new LoadFlowViewModel(U, normalSigma);
/*
* var viewModel = new List<LoadFlowViewModel>();
* for(int z = 0; z <= (N_bus-1); z++)
* {
* var row = new LoadFlowViewModel();
* row.busNo = z;
* row.resultU = U[z];
* row.resultSigma = normalSigma[z];
* viewModel.Add(row);
* }
* return viewModel;
*/
var list = new LoadFlows();
list.Results = new List <LoadFlowResult>();
for (int z = 0; z <= (N_bus - 1); z++)
{
var a = new LoadFlowResult()
{
busNo = z, resultU = U[z], resultSigma = normalSigma[z]
};
list.Results.Add(a);
}
return(list.Results);
}
