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);
        }
Esempio n. 2
0
            public bool ContainsResource(S resource)
            {
                Node n;

                if (!Owner.resourceMap.TryFindValue(resource, out n))
                {
                    return(false);
                }

                return(InternalNodes.Contains(n));
            }
        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);
        }
        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);
        }