Una posibilidad de solución de un circuito eléctrico, es la solución
utilizando análisis de nodos la cual, consiste
en solucionar un sistema de ecuaciones dada por
G v = I
donde:
G es la matriz de conductancias
v el vector de voltajes nodales e
I el vector de corriente en cada nodo.
La descripción del circuito la haremos en un
archivo de datos y consideraremos que un elemento esta conectado a un par de
nodos. Un nodo será de salida y otro de entrada tal como se muestra en la siguiente
tabla:
Elem. No. k |
Nodo salida i |
Nodo entrada j |
Conductancia mho g |
Fuente corriente F |
1 |
0 |
1 |
1 |
1 |
2 |
1 |
2 |
2 |
0 |
3 |
2 |
0 |
3 |
0 |
4 |
2 |
3 |
2 |
0 |
5 |
3 |
0 |
4 |
-5 |
6 |
1 |
3 |
0 |
3 |
nota: la información en amarillo no es parte
del archivo de datos.
De tabla anterior podemos ver que el circuito
esta formado por cuatros nodos, numerados del 0 al 3 y que este tiene 6
elementos. Por lo tanto, solucionaremos un sistema de tres ecuaciones con tres
incógnitas.
Para una conductancia g conectada entre el nodo
i y el j con una fuente de Corriente F, tomadas de la tabla, llenaremos la
matriz de conductancias G y el vector de corrientes utilizando las siguientes
reglas.
1.- Si tanto los nodo i y j son diferentes de
cero, hacemos:
Gi,j = Gi,j
- g
Gj,i = Gj,i - g
2.- Si el j-esimo nodo es diferente de cero,
hacemos:
Gi,i = Gi,i + g
Ii = Ii - F
3.- Si el j-esimo nodo diferente de cero,
hacemos:
Gj,j = Gj,j + g
Ij = Ij + F
Aplicando estos paso tenemos:
Para el elemento 1 tendremos:
1 |
0 |
0 |
|
V1 |
|
1 |
0 |
0 |
0 |
|
V2 |
= |
0 |
0 |
0 |
0 |
|
V3 |
|
0 |
Para el elemento 2:
3 |
-2 |
0 |
|
V1 |
|
1 |
-2 |
2 |
0 |
|
V2 |
= |
0 |
0 |
0 |
0 |
|
V3 |
|
0 |
Para el elemento 3
3 |
-2 |
0 |
|
V1 |
|
1 |
-2 |
5 |
0 |
|
V2 |
= |
0 |
0 |
0 |
0 |
|
V3 |
|
0 |
Para 4
3 |
-2 |
0 |
|
V1 |
|
-2 |
-2 |
7 |
-2 |
|
V2 |
= |
0 |
0 |
-2 |
2 |
|
V3 |
|
8 |
Para 5
3 |
-2 |
0 |
|
V1 |
|
1 |
-2 |
7 |
-2 |
|
V2 |
= |
0 |
0 |
-2 |
6 |
|
V3 |
|
5 |
Finalmente para el elemento 6
3 |
-2 |
0 |
|
V1 |
|
1 |
-2 |
7 |
-2 |
|
V2 |
= |
0 |
0 |
-2 |
6 |
|
V3 |
|
8 |
La solución de este sistema es :
V1 |
|
-0.4889 |
V2 |
= |
0.2667 |
V3 |
|
1.4222 |
La implementación en Java queda como:
/**
* Programa para resolver un circuito
utilizando analisis nodal
* Este programa lee la descripción de un
circuito y lo soluciona
* Copyright:
Copyright (c) 2003</p>
* UMSNH
* Dr. Felix Calderon Solorio
* @version 1.0
*/
public
class ej027 {
public static void main(String[] args) {
Matriz desc = new Matriz("cto.txt");
int i, j, k, nodos = 0;
for(k=0; k<desc.nren; k++)
{
if (nodos < desc.datos[k][0]) nodos =
(int) desc.datos[k][0];
if (nodos < desc.datos[k][1]) nodos =
(int) desc.datos[k][1];
}
Matriz G = new Matriz(nodos, nodos);
Matriz v = new Matriz(nodos, 1);
Matriz I = new
Matriz(nodos, 1);
for(k=0; k<desc.nren; k++)
{
i = (int) desc.datos[k][0];
j = (int) desc.datos[k][1];
if(i!=0 && j != 0)
{
G.datos[i - 1][j - 1] -= desc.datos[k][2];
G.datos[j - 1][i - 1] -=
desc.datos[k][2];
}
if(i!=0)
{
G.datos[i-1][i-1] += desc.datos[k][2];
I.datos[i-1][0] -= desc.datos[k][3];
}
if(j!=0)
{
G.datos[j-1][j-1] += desc.datos[k][2];
I.datos[j-1][0] += desc.datos[k][3];
}
}
G.imprime();
I.imprime();
v.eliminacion_gaussiana(G, I);
v.sustitucion_hacia_atras(G,I);
v.imprime();
}
}
Un formato estándar
muy utilizado es el del programa de Pspice. Para un circuito simple, formado
por resistencias, fuentes de corriente y fuentes de voltaje, la descripción se
hace de la siguiente manera:
Tipo de Elemento |
Nodo salida |
Nodo entrada |
Valor |
V1 |
0 |
1 |
20 |
I2 |
1 |
2 |
2 |
R23 |
2 |
0 |
3.5 |
Para describir un
elemento hacemos:
1.- Dar un nombre que
comenzará con V, I o R si se trata de una fuente de voltaje, corriente o
resistencia respectivamente.
2.- Dar la
información del par de nodos a los cuales esta conectado. El nodo de salida indicará
el nodo negativo del elemento y el nodo de entrada el nodo positivo del
elemento.
3.- Dar el valor de la fuente en unidades del
Sistema internacional, por ejemplo, Volts, Amperes y ohms de acuerdo al tipo de
elemento.
import java.io.*;
import java.util.*;
import javax.swing.*;
/**
* Programa para leer Un archivo
en formato Pspice
* Lee los datos de un archivo y
soluciona el circuito.
*
Copyright: Copyright (c) 2003
* Company: UMSNH
* @author Dr. Felix Calderon
Solorio.
* @version 1.0
*/
public class ej028 {
public static void
main(String[] args)
{
int nodos;
String archivo =
"resnick.txt";
nodos
= NumNodos(archivo);
Matriz G = new Matriz(nodos,
nodos);
Matriz
I = new Matriz(nodos, 1);
Matriz
v = new Matriz(nodos, 1);
LlenaSistema(G, I, archivo);
G.imprime();
I.imprime();
v.eliminacion_gaussiana(G,
I);
G.imprime();
v.sustitucion_hacia_atras(G,
I);
v.imprime();
}
public static int
NumNodos(String archivo) {
StringTokenizer st;
String linea, elemento,
inicio, fin;
int nodos = 0, val;
try {
RandomAccessFile DIS = new
RandomAccessFile(archivo, "r");
while ( (linea =
DIS.readLine()) != null) {
st = new
StringTokenizer(linea);
if (st.countTokens() !=
0) {
elemento =
st.nextToken();
inicio = st.nextToken();
fin = st.nextToken();
val = (int)
Double.valueOf(inicio).doubleValue();
if(val > nodos) nodos = val;
val = (int) Double.valueOf(fin).doubleValue();
if(val > nodos) nodos = val;
}
}
DIS.close();
}
catch (IOException e) {
JOptionPane.showMessageDialog(null, "Error" + e.toString(),
"ERROR",
JOptionPane.ERROR_MESSAGE);
}
return nodos;
}
//
***********************************************************************
public static void
LlenaSistema(Matriz G, Matriz I, String archivo) {
StringTokenizer st;
String linea, elemento, inicio,
fin, valor;
char tipo ;
int i, j;
double val;
try {
RandomAccessFile DIS = new
RandomAccessFile(archivo, "r");
while ( (linea =
DIS.readLine()) != null) {
st = new
StringTokenizer(linea);
if (st.countTokens() !=
0) {
elemento =
st.nextToken();
inicio = st.nextToken();
fin = st.nextToken();
valor = st.nextToken();
tipo = elemento.charAt(0);
i = (int)
Double.valueOf(inicio).doubleValue();
j = (int) Double.valueOf(fin).doubleValue();
val = Double.valueOf(valor).doubleValue();
switch(tipo)
{
case 'R': case 'r':
if(i!=0 &&
j != 0)
{
G.datos[i - 1][j
- 1] -= 1.0/val;
G.datos[j - 1][i
- 1] -= 1.0/val;
}
if(i!=0)
G.datos[i-1][i-1] += 1.0/val;
if(j!=0)
G.datos[j-1][j-1] += 1.0/val;
break;
case 'I': case 'i':
if(i!=0)
I.datos[i-1][0] -= val;
if(j!=0)
I.datos[j-1][0] += val;
break;
case 'V': case 'v':
val = val / 1e-06;
if(i!=0) I.datos[i-1][0] -= val;
if(j!=0) I.datos[j-1][0] += val;
val = 1e+06;
if(i!=0 && j != 0)
{
G.datos[i - 1][j
- 1] -= val;
G.datos[j - 1][i
- 1] -= val;
}
if(i!=0)
G.datos[i-1][i-1] += val;
if(j!=0)
G.datos[j-1][j-1] += val;
}
}
}
DIS.close();
}
catch (IOException e) {
JOptionPane.showMessageDialog(null, "Error" + e.toString(),
"ERROR",
JOptionPane.ERROR_MESSAGE);
}
}
}