public ParallelBlock(ComponentContainer owner, Dipole comp1, Dipole comp2) : base(owner)
{
Components.Add(comp1);
Components.Add(comp2);
Nodes.Add(comp1.Nodes[0]);
Nodes.Add(comp1.Nodes[1]);
}
/// <summary>
/// Dado 1 nodo interno de la rama, busca el nodo externo mas cercano al componente
/// </summary>
/// <param name="internalnode"></param>
/// <returns></returns>
public Node FindBranchExternalNode(Node internalnode, Dipole component)
{
if (!InternalNodes.Contains(internalnode))
{
//la rama no contiene al nodo indicado, probablemene un error
return(null);
}
if (!component.Nodes.Contains(internalnode))
{
//el componente no contiene el nodo, un error
return(null);
}
Dipole comp = null, comp2 = null;
Node n = null;
n = internalnode;
throw new NotImplementedException();
while (!Nodes.Contains(n))
{
//busco componente a componente, nodo a nodo
comp2 = n.OtherComponent(comp);
n = comp2.OtherNode(n);
}
return(n);
}
public ParallelBlock(ComponentContainer owner, Dipole comp1, Dipole comp2):base(owner)
{
Components.Add(comp1);
Components.Add(comp2);
Nodes.Add(comp1.Nodes[0]);
Nodes.Add(comp1.Nodes[1]);
}
public virtual double TheveninVoltage(Node referenceNode, double t)
{
double v = 0;
Dipole compo1 = null;
Node node1 = null;
foreach (var item in Components)
{
if (item.Nodes[0] == referenceNode || item.Nodes[1] == referenceNode)
{
compo1 = item;
break;
}
}
node1 = referenceNode;
do
{
if (compo1 is Branch)
{
v += ((Branch)compo1).TheveninVoltage(node1, t);
}
else
{
v += compo1.voltage(node1, t);
}
node1 = compo1.OtherNode(node1);
compo1 = node1.OtherComponent(compo1);
} while (InternalNodes.Contains(node1));
return(v);
}
public Dipole OtherComponent(Dipole compo)
{
if (compo == Components[0])
{
return(Components[1]);
}
else
{
return(Components[0]);
}
}
/// <summary>
/// Dado 1 nodo extremo de la rama, busca el nodo mas cercano al componente
/// </summary>
/// <param name="externalnode">one of two exterior branch nodes</param>
/// <returns></returns>
public Node FindComponentNode(Node externalnode, Dipole component)
{
Node n = null;
if (!Nodes.Contains(externalnode))
{
//la rama no contiene al nodo indicado, probablemene un error
return(null);
}
Dipole comp = null;
//if (Nodes.Contains(originalnode))
//identifico al componente que contiene el nodo externo
foreach (var comp1 in Components)
{
if (comp1.Nodes[0] == externalnode || comp1.Nodes[1] == externalnode)
{
comp = comp1;
break;
}
}
n = externalnode;
do
{
if (comp == component)
{
return(n);
}
//busco componente a componente, nodo a nodo
n = comp.OtherNode(n);
comp = n.OtherComponent(comp);
} while (InternalNodes.Contains(n));
//error, no se encontro elcompente que contine el nodo!
return(null);
}
public virtual Complex32 NortonCurrent(Node referenceNode, Complex32?W = null)
{
Complex32 v = 0, z = 0;
Dipole compo1 = null;
Node node1 = null;
//encuentro el componente unido al nodo de referencia
foreach (var item in Components)
{
if (item.Nodes[0] == referenceNode || item.Nodes[1] == referenceNode)
{
compo1 = item;
break;
}
}
//a partir del nodo y el componente, escaneo la ramaenbusca de la Vthevenin y la Rthevenin
node1 = referenceNode;
do
{
if (compo1 is Branch)
{
v += ((Branch)compo1).TheveninVoltage(node1, W);
}
else if (compo1 is ACVoltageGenerator)
{
v += compo1.voltage(node1, W);
}
//los componentes pasivos no tienen tension en barrido en frecuencia
z += compo1.Impedance(W);
node1 = compo1.OtherNode(node1);
compo1 = node1.OtherComponent(compo1);
} while (InternalNodes.Contains(node1));
return(v / z);
}
public virtual double NortonCurrent(Node referenceNode, double t)
{
if (CurrentImposser != null)
{
return(Current(referenceNode, t));
}
double v = 0, z = 0;
Dipole compo1 = null;
Node node1 = null;
foreach (var item in Components)
{
if (item.Nodes[0] == referenceNode || item.Nodes[1] == referenceNode)
{
compo1 = item;
break;
}
}
node1 = referenceNode;
do
{
if (compo1 is Branch)
{
v += ((Branch)compo1).TheveninVoltage(node1, t);
}
else
{
v += compo1.voltage(node1, t);
}
z += compo1.Impedance().Real;
node1 = compo1.OtherNode(node1);
compo1 = node1.OtherComponent(compo1);
} while (InternalNodes.Contains(node1));
return(v / z);
}
/// <summary>
/// barre una rama desde un nodo interno hacia la izquierda o derecha
/// calculando la suma de las tensiones de generadores V1
/// y la suma de impedancias Z1
/// </summary>
/// <param name="nodo"></param>
/// <param name="compo1"></param>
/// <param name="t"></param>
/// <param name="v1"></param>
/// <param name="z1"></param>
private static void NavigateBranch(Node nodo, Dipole compo1, double t, ref double v1, ref double z1)
{
Node nodo1 = nodo;
while (!(nodo1.TypeOfNode == Node.NodeType.MultibranchCurrentNode || nodo1.IsReference))
{
if (compo1 is Resistor)
{
z1 += compo1.Impedance().Real;
}
else if (compo1 is VoltageGenerator || compo1 is Capacitor)
{
v1 += compo1.voltage(nodo1, t);
}
else
{
throw new NotImplementedException();
}
nodo1 = compo1.OtherNode(nodo1);
compo1 = nodo1.OtherComponent(compo1);
}
if (nodo1.TypeOfNode == Node.NodeType.MultibranchCurrentNode)
{
v1 += nodo1.Voltage.Real;
}
}
/// <summary>
/// Dado un supernodo, recorre todas sus ramas para hallar la corriente en una de ellas
/// </summary>
/// <param name="nodo"></param>
/// <param name="W"></param>
/// <returns></returns>
private static double CalculateSupernodeCurrent(Node nodo, Dipole comp, double t)
{
if (nodo.IsReference)
nodo = comp.OtherNode(nodo);
double i = 0;
foreach (var comp2 in nodo.Components)
{
if (comp2 == comp)
{
continue;
}
if (comp2 is VoltageGenerator)
{
Node nodo1 = comp2.OtherNode(nodo);
i += CalculateSupernodeCurrent(nodo1, comp2, t);
}
else
i += comp2.Current(nodo, t);
}
return i;
}
protected static Branch FindBranch(Circuit cir, Node initialNode, Dipole Component)
{
Branch br = new Branch(cir);
Dipole compo = Component;
Node nodo = Component.OtherNode(initialNode);
br.Nodes.Clear();
//solo es valido si el circuito fue optimizado, y los paralelos
//se reemplazaron por bloques paralelo
while (nodo.Components.Count == 2 && cir.Reference != nodo)
{
br.Components.Add(compo);
br.InternalNodes.Add(nodo);
compo = nodo.OtherComponent(compo);
nodo = compo.OtherNode(nodo);
}
br.Components.Add(compo);
if (br.Components.Count > 1)
{
initialNode.Components.Remove(Component);
initialNode.Components.Add(br);
nodo.Components.Remove(compo);
nodo.Components.Add(br);
nodo.TypeOfNode = Node.NodeType.MultibranchCurrentNode;
}
br.Nodes.Add(initialNode);
br.Nodes.Add(nodo);
//hay que recorrer la rama para buscar los nodos intermedios flotantes
//y aquellos dependientes de los flotantes
nodo = compo.OtherNode(nodo);
while (nodo != initialNode)
{
if (nodo.TypeOfNode == Node.NodeType.VoltageFixedNode)
{
// nothing, node was calculated
}
else if (compo is VoltageGenerator || compo is Capacitor)
{
if (nodo.TypeOfNode == Node.NodeType.Unknow)
nodo.TypeOfNode = Node.NodeType.VoltageLinkedNode;
else
throw new NotImplementedException();
}
else if (compo is Resistor)
{
if (nodo.TypeOfNode == Node.NodeType.Unknow)
nodo.TypeOfNode = Node.NodeType.VoltageDivideNode;
else
throw new NotImplementedException();
}
else if (compo is Inductor || compo is CurrentGenerator)
{
//nada, solo imponen la corriente
}
else
{
if (nodo.TypeOfNode == Node.NodeType.Unknow)
nodo.TypeOfNode = Node.NodeType.InternalBranchNode;
else
throw new NotImplementedException();
}
compo = nodo.OtherComponent(compo);
nodo = compo.OtherNode(nodo);
}
return br;
}
/// <summary>
/// Valida una rama y la agrega al circuito si corresponde
/// En caso contrario solo agrega el componente indicado
/// </summary>
/// <param name="yaanalizados"></param>
/// <param name="nodosnormales"></param>
/// <param name="ramas"></param>
/// <param name="nodo"></param>
/// <param name="compo"></param>
/// <param name="br"></param>
protected static void ValidateBranch(List<Dipole> yaanalizados, List<Node> nodosnormales,
List<Branch> ramas, Node nodo, Dipole compo, Branch br)
{
if (br.Components.Count <= 1)
{
if (compo is PasiveComponent)
{
Node other = compo.OtherNode(nodo);
other.TypeOfNode = Node.NodeType.MultibranchCurrentNode;
if (!nodosnormales.Contains(other))
nodosnormales.Add(other);
}
yaanalizados.Add(compo);
}
else
{
//rama valida
ramas.Add(br);
Node other = br.OtherNode(nodo);
if (!nodosnormales.Contains(other))
nodosnormales.Add(other);
yaanalizados.AddRange(br.Components);
foreach (var comp in br.Components)
{
comp.Owner = br;
}
}
}
/// <summary>
/// Dado un supernodo, recorre todas sus ramas para hallar la corriente en una de ellas
/// </summary>
/// <param name="nodo"></param>
/// <param name="W"></param>
/// <returns></returns>
private static Complex32 CalculateSupernodeCurrent(Node nodo, Complex32 W, Dipole comp)
{
Complex32 i = Complex32.Zero;
foreach (var comp2 in nodo.Components)
{
if (comp2 == comp)
{
continue;
}
if (comp2 is VoltageGenerator)
{
Node nodo1 = comp2.OtherNode(nodo);
i += CalculateSupernodeCurrent(nodo1, W, comp2);
}else
i += comp2.Current(nodo, W);
}
return i;
}
/// <summary>
/// barre una rama desde un nodo interno hacia la izquierda o derecha
/// calculando la suma de las tensiones de generadores V1
/// y la suma de impedancias Z1
/// </summary>
/// <param name="nodo"></param>
/// <param name="compo1"></param>
/// <param name="W"></param>
/// <param name="v1"></param>
/// <param name="z1"></param>
private static void NavigateBranch(Node nodo , Dipole compo1, Complex32 W, ref Complex32 v1, ref Complex32 z1)
{
Node nodo1 = nodo;
while (!(nodo1.TypeOfNode == Node.NodeType.MultibranchCurrentNode || nodo1.IsReference))
{
if (nodo1.TypeOfNode == Node.NodeType.VoltageFixedNode)
{
//llegue al final de la rama
v1 += nodo1.Voltage;
break;
}
if (compo1 is PasiveComponent)
{
z1 += compo1.Impedance(W);
}
else if (compo1 is VoltageGenerator)
{
v1 += compo1.voltage(nodo1, W);
}
else
{
throw new NotImplementedException();
}
nodo1 = compo1.OtherNode(nodo1);
compo1 = nodo1.OtherComponent(compo1);
}
if (nodo1.TypeOfNode == Node.NodeType.MultibranchCurrentNode && !nodo1.IsReference)
{
v1 += nodo1.Voltage;
}
}
/// <summary>
/// Dado 1 nodo interno de la rama, busca el nodo externo mas cercano al componente
/// </summary>
/// <param name="internalnode"></param>
/// <returns></returns>
public Node FindBranchExternalNode(Node internalnode, Dipole component)
{
if (!InternalNodes.Contains(internalnode))
{
//la rama no contiene al nodo indicado, probablemene un error
return null;
}
if (!component.Nodes.Contains(internalnode))
{
//el componente no contiene el nodo, un error
return null;
}
Dipole comp = null, comp2 = null;
Node n = null;
n = internalnode;
throw new NotImplementedException();
while (!Nodes.Contains(n))
{
//busco componente a componente, nodo a nodo
comp2 = n.OtherComponent(comp);
n = comp2.OtherNode(n);
}
return n;
}
protected static void AddComponentNodes(Circuit ciroptimizado, Dipole rama)
{
if (!ciroptimizado.Nodes.ContainsValue(rama.Nodes[0]))
ciroptimizado.Nodes.Add(rama.Nodes[0].Name, rama.Nodes[0]);
if (!ciroptimizado.Nodes.ContainsValue(rama.Nodes[1]))
ciroptimizado.Nodes.Add(rama.Nodes[1].Name, rama.Nodes[1]);
}
public SpecialComponentInfo(Dipole comp)
{
Component = comp;
ImportantInputNodes = new List<Node>();
ImportantOutputNodes = new List<Node>();
}
/// <summary>
/// Dado 1 nodo extremo de la rama, busca el nodo mas cercano al componente
/// </summary>
/// <param name="externalnode">one of two exterior branch nodes</param>
/// <returns></returns>
public Node FindComponentNode(Node externalnode, Dipole component)
{
Node n = null;
if (!Nodes.Contains(externalnode))
{
//la rama no contiene al nodo indicado, probablemene un error
return null;
}
Dipole comp = null;
//if (Nodes.Contains(originalnode))
//identifico al componente que contiene el nodo externo
foreach (var comp1 in Components)
{
if (comp1.Nodes[0] == externalnode || comp1.Nodes[1] == externalnode)
{
comp = comp1;
break;
}
}
n = externalnode;
do
{
if (comp == component)
{
return n;
}
//busco componente a componente, nodo a nodo
n = comp.OtherNode(n);
comp = n.OtherComponent(comp);
} while (InternalNodes.Contains(n));
//error, no se encontro elcompente que contine el nodo!
return null;
}
public Dipole OtherComponent(Dipole compo)
{
if (compo == Components[0])
return Components[1];
else
return Components[0];
}
