protected static void CalculateCurrents(ComponentContainer container, Complex32 W)
{
foreach (var comp in container.Components)
{
//la corriente en las resistencias se calcula directamente en ellas: es ley de Ohm:V/R
if (comp is PasiveComponent || comp is CurrentGenerator)
{
Node nodo = comp.Nodes[0];
comp.current = comp.Current(nodo, W);
if (container is Branch)
{
((Branch)container).current = comp.current;
}
continue;
}
//en los Generadores de tension hay que calcular la corriente en 1 u ambos nodos
if (comp is VoltageGenerator)
{
foreach (var nodo in comp.Nodes)
{
Dipole comp2 = nodo.OtherComponent(comp);
//si tiene solo un resistor en serie es automatico el valor de corriente
if (nodo.Components.Count == 2 && (comp2 is PasiveComponent || comp2 is CurrentGenerator))
{
comp.current = comp2.Current(nodo, W);
if (container is Branch)
{
((Branch)container).current = comp.current;
}
goto out1;
}
}
//si no tiene solo una resistencias en serie, es decir, un nodo de multiples ramas
//se aplica 2da de Kirchoff para el supernodo
// throw new NotImplementedException();
foreach (var nodo in comp.Nodes)
{
if (nodo.IsReference)
{
continue;
}
Complex32 i = Complex32.Zero;
i = CalculateSupernodeCurrent(nodo, W, comp);
comp.current = i;
break;
}
}
else if (comp is Branch)
{
CalculateCurrents((Branch)comp, W);
continue;
}
else if (comp is ParallelBlock)
{
CalculateCurrents((ParallelBlock)comp, W);
continue;
}
out1 :;
}
}
/// <summary>
/// Calculate Statics components currents
/// </summary>
/// <param name="container"></param>
private static void CalculateCurrents(ComponentContainer container)
{
foreach (var comp in container.Components)
{
//la corriente de DC de un capacitor es 0
if (comp is Capacitor)
{
continue;
}
//la corriente en las resistencias se calcula directamente en ellas: es ley de Ohm:V/R
if (comp is Resistor || comp is CurrentGenerator)
{
if (container is Branch)
{
Node nodo = comp.Nodes[0];
((Branch)container).current = comp.Current(nodo);
}
continue;
}
//en los Generadores de tension hay que calcular la corriente en 1 u ambos nodos
if (comp is VoltageGenerator || comp is Inductor)
{
foreach (var nodo in comp.Nodes)
{
Dipole comp2 = nodo.OtherComponent(comp);
//si tiene solo un resistor en serie es automatico el valor de corriente
if (nodo.Components.Count == 2 && (comp2 is Resistor || comp2 is CurrentGenerator))
{
//Node nodo2 = com
comp.current = comp2.Current(nodo);
if (container is Branch)
{
((Branch)container).current = comp.Current(nodo);
}
goto out1;
}
}
//si no tiene solo una resistencias en serie, es decir, un nodo de multiples ramas
//se aplica 2da de Kirchoff para el supernodo
throw new NotImplementedException();
foreach (var nodo in comp.Nodes)
{
Complex32 i;
foreach (var comp2 in nodo.Components)
{
}
}
}
else if (comp is Branch)
{
CalculateCurrents((Branch)comp);
continue;
}
else if (comp is ParallelBlock)
{
CalculateCurrents((ParallelBlock)comp);
continue;
}
out1 :;
}
}
protected static void CalculateCurrents(ComponentContainer container, double t)
{
foreach (var comp in container.Components)
{
//la corriente en las resistencias se calcula directamente en ellas: es ley de Ohm:V/R
if (comp is CurrentGenerator || comp is Inductor || comp is Resistor)
{
Node nodo = comp.Nodes[0];
//comp.current = new Complex32((float)comp.Current(nodo, t), 0);
if (container is Branch)
{
((Branch)container).current = new Complex32((float)comp.Current(nodo, t), 0);
}
continue;
}
//en los Generadores de tension hay que calcular la corriente en 1 u ambos nodos
if (comp is VoltageGenerator || comp is Capacitor)
{
foreach (var nodo in comp.Nodes)
{
if (nodo.IsReference)
{
continue;
}
Dipole comp2 = nodo.OtherComponent(comp);
//si tiene solo un resistor en serie es automatico el valor de corriente
if (nodo.Components.Count == 2 && (comp2 is Resistor || comp2 is CurrentGenerator || comp2 is Inductor))
{
if (nodo == comp.Nodes[0])
{
comp.current = new Complex32((float)comp2.Current(nodo, t), 0);
}
else
{
comp.current = new Complex32((float)-comp2.Current(nodo, t), 0);
}
if (container is Branch)
{
((Branch)container).current = comp.current;
}
goto out1;
}
}
Node node = comp.Nodes[0];
//si no tiene solo una resistencias en serie, es decir, un nodo de multiples ramas
//se aplica 2da de Kirchoff para el supernodo
comp.current = new Complex32((float)CalculateSupernodeCurrent(node, comp, t), 0);
}
else if (comp is Branch)
{
CalculateCurrents((Branch)comp, t);
continue;
}
else if (comp is ParallelBlock)
{
CalculateCurrents((ParallelBlock)comp, t);
continue;
}
out1 :;
}
}
