Manual de Código Fuente by Ayose Lomba Pérez

Uni ver s i daddeLasPal masdeGr anCanar i a Es cuel aTécni caSuper i ordeI ngeni er osI ndus t r i al es I ngeni er í aI ndus t r i al

Sof t war edeanál i s i sdeci r cui t osl i neal es medi ant emét odosavanzadosde r es ol uci ónpar aus odocent e.

ManualdeCódi goFuent e

Aut or :

Tut or es : Fecha:

Ayos eLombaPér ez Jos eMi guelMonzónVer ona Ant oni oAndr ésOcónCar r er as Sept i embr e2009

ÍNDICE

Índice 1. Ávalon.

2. Indice de módulos

2.1. Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3. Índice de clases 3.1. Lista de clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4. Indice de archivos 4.1. Lista de archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5. Documentación de módulos

2 2 2 3 3 3

5.1. Generación de las variables del sistema matricial Tx=W . . . . . . . . . . . . . . . . . . .

5.1.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.1.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.2. Forma de cargar los distintos elementos que componen un circuito . . . . . . . . . . . . .

5.2.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.2.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.3. Métodos de resolución . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.3.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.3.2. Slots públicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.3.3. Slots protegidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.4. Resolución de Permanente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.4.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.4.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.5. Resolución de Transitorio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.5.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.5.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.6. Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.6.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.6.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.7. Selección de filas en las Qtable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.7.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.7.2. Slots públicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.8. Creación del sistema general de ecuaciones lineales . . . . . . . . . . . . . . . . . . . . .

5.8.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

1 Ávalon.

5.9. Ensamblaje los elementos en el sistema lineal . . . . . . . . . . . . . . . . . . . . . . . .

5.9.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.9.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.10. Ensamblaje sobre la Matriz T . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.10.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.10.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.11. Ensamblaje sobre el Vector W . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.11.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5.11.2. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . .

6. Documentación de las clases

6.1. Referencia de la Estructura basicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.1.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.1.2. Documentación de las funciones miembro . . . . . . . . . . . . . . . . . . . . . .

6.1.3. Documentación de los datos miembro . . . . . . . . . . . . . . . . . . . . . . . .

6.2. Referencia de la Estructura sbcl_principal . . . . . . . . . . . . . . . . . . . . . . . . . .

6.2.1. Descripción detallada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

6.2.2. Documentación del constructor y destructor . . . . . . . . . . . . . . . . . . . . .

6.2.3. Documentación de las funciones miembro . . . . . . . . . . . . . . . . . . . . . .

6.2.4. Documentación de los datos miembro . . . . . . . . . . . . . . . . . . . . . . . .

7. Documentación de archivos

7.1. Referencia del Archivo Programacion/AVALON/src/cabeceras.h . . . . . . . . . . . . . .

7.1.1. Documentación de las definiciones . . . . . . . . . . . . . . . . . . . . . . . . . .

7.2. Referencia del Archivo Programacion/AVALON/src/elementos.cpp . . . . . . . . . . . . .

7.3. Referencia del Archivo Programacion/AVALON/src/elementos.h . . . . . . . . . . . . . . 101 7.4. Referencia del Archivo Programacion/AVALON/src/estructuras.cpp . . . . . . . . . . . . 103 7.4.1. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 7.5. Referencia del Archivo Programacion/AVALON/src/estructuras.h . . . . . . . . . . . . . . 106 7.5.1. Documentación de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 7.6. Referencia del Archivo Programacion/AVALON/src/sbcl_principal.cpp . . . . . . . . . . 109 7.7. Referencia del Archivo Programacion/AVALON/src/sbcl_principal.h . . . . . . . . . . . . 109

Ávalon.

Documentación del código del PFC denominado "Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente" Esta documentación pretende ser una guía para aquellos que deseen mejorar el funcionamiento del progra-

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

2 Indice de módulos

ma o realizar una ampliación del mismo. Se ha intentado realizar una guía rápida de consulta para tener presente en todo momento la función de cada variable, estructura, clase y función que componen este programa de análisis de circuitos para la Escuela Técnica Superior de Ingenieros Industriales de Las Palmas de Gran Canaria. Autor: Ayose Lomba Pérez Fecha: Septiembre 2009

Indice de módulos

2.1.

Módulos

Lista de todos los módulos: Métodos de resolución

Resolución de Permanente

Resolución de Transitorio

Resultados

Selección de filas en las Qtable

Creación del sistema general de ecuaciones lineales

Generación de las variables del sistema matricial Tx=W

Forma de cargar los distintos elementos que componen un circuito

Ensamblaje los elementos en el sistema lineal

Ensamblaje sobre la Matriz T

Ensamblaje sobre el Vector W

Índice de clases

3.1.

Lista de clases

Lista de las clases, estructuras, uniones e interfaces con una breve descripción: basicos (Estructura que almacena datos de interés para el correcto funcionamiento del programa ) 76 sbcl_principal (Clase en la que se encuentran los diferentes slots utilizados para hacer funcionar la parte gráfica del programa ) 86

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

4 Indice de archivos

Indice de archivos

4.1.

Lista de archivos

Lista de todos los archivos con descripciones breves: Programacion/AVALON/src/cabeceras.h

Programacion/AVALON/src/elementos.cpp

Programacion/AVALON/src/elementos.h

101

Programacion/AVALON/src/estructuras.cpp

103

Programacion/AVALON/src/estructuras.h

106

Programacion/AVALON/src/sbcl_principal.cpp

109

Programacion/AVALON/src/sbcl_principal.h

109

5. 5.1.

Documentación de módulos Generación de las variables del sistema matricial Tx=W

Diagrama de colaboración para Generación de las variables del sistema matricial Tx=W: Creación del sistema general de ecuaciones lineales

Generación de las variables del sistema matricial Tx=W

Conjunto de funciones que se encarga de preparar los elementos del sistema matricial Tx=W . Funciones Mat basicos::creaT () Se encarga de dimensionar la matriz T del sistema a resolver. NOTA: La matriz T es una matriz sparse generada con las funciones de la librería PETCs.

void basicos::creaGC () Se encarga de dimensionar las matrices del sistema transitorio G y C. NOTA: La matrices G y C son matrices sparse generadas con las funciones de la librería PETCs.

Vec basicos::creaW () Se encarga de dimensionar el vector W para el sistema estacionario NOTA: El vector W es un vector generado con las funciones de la librería PETCs.

Vec basicos::creaWn () Se encarga de dimensionar el vector Wn para el sistema transitorio NOTA: El vector Wn es un vector generado con las funciones de la librería PETCs.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.1

Generación de las variables del sistema matricial Tx=W

Vec basicos::creaWn1 () Se encarga de dimensionar el vector Wn1 para el sistema transitorio NOTA: El vector Wn1 es un vector generado con las funciones de la librería PETCs.

Vec basicos::creax_perm () Se encarga de dimensionar el vector x para el sistema estacionario. En el se almacenan las soluciones del mismo. NOTA: El vector x_perm es un vector generado con las funciones de la librería PETCs.

Vec basicos::creax_trans () Se encarga de dimensionar el vector x para el sistema transitorio. En el se almacenan las soluciones del mismo. NOTA: El vector x_trans es un vector generado con las funciones de la librería PETCs.

void dimensiona (int ∗num_line_total, basicos ∗DATOS) Se encarga de dimensionar la matriz T y el vector W para el posterior cálculo del sistema que nos proporcionará la solución del circuito. Tras calcular la dimensión de la misma se encarga de la creación de la T y W.

int num_nodos (int ∗num_line_total, basicos ∗p_DATOS) Calcula el número de nodos del circuito. Para ello realiza un barrido por la qtable MN buscando el mayor valor introducido.

int num_elemA2 (int ∗, basicos ∗) Calcula el número de elementos pertenecientes al grupo A2. Para ello realiza un barrido por la qtable MDG buscando los elementos del grupo A2.

int num_EA (int ∗num_line_total, basicos ∗p_DATOS) Calcula el número de elementos que se han considerado ecuación adicional. Para ello realiza un barrido por la qtable MDG sumando el número de ecuaciones adicionales existentes.

5.1.1.

Descripción detallada

Conjunto de funciones que se encarga de preparar los elementos del sistema matricial Tx=W . 5.1.2. 5.1.2.1.

Documentación de las funciones void basicos::creaGC () [inline, inherited]

Se encarga de dimensionar las matrices del sistema transitorio G y C. NOTA: La matrices G y C son matrices sparse generadas con las funciones de la librería PETCs. Definición en la línea 110 del archivo estructuras.h. 111 112 113 114 115 116

{ MatCreateSeqAIJ(PETSC_COMM_SELF,filas(),columnas(),10,PETSC_NULL,&G); MatAssemblyBegin(G,MAT_FINAL_ASSEMBLY); MatAssemblyEnd(G,MAT_FINAL_ASSEMBLY); MatCreateSeqAIJ(PETSC_COMM_SELF,filas(),columnas(),10,PETSC_NULL,&C); MatAssemblyBegin(C,MAT_FINAL_ASSEMBLY); MatAssemblyEnd(C,MAT_FINAL_ASSEMBLY); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.1

Generación de las variables del sistema matricial Tx=W

5.1.2.2.

Mat basicos::creaT () [inline, inherited]

Se encarga de dimensionar la matriz T del sistema a resolver. NOTA: La matriz T es una matriz sparse generada con las funciones de la librería PETCs. Devuelve: Retorna un puntero a una matriz PETCs Definición en la línea 100 del archivo estructuras.h. 101 102 103 104 105

{ MatCreateSeqAIJ(PETSC_COMM_SELF,filas(),columnas(),10,PETSC_NULL,&T); MatAssemblyBegin(T,MAT_FINAL_ASSEMBLY); MatAssemblyEnd(T,MAT_FINAL_ASSEMBLY); return T; }

5.1.2.3.

Vec basicos::creaW () [inline, inherited]

Se encarga de dimensionar el vector W para el sistema estacionario NOTA: El vector W es un vector generado con las funciones de la librería PETCs. Devuelve: Retorna un puntero a un vector PETCs Definición en la línea 123 del archivo estructuras.h. 124 125 126 127 128 129 130

{ VecCreate(PETSC_COMM_SELF,&W); VecSetSizes(W,PETSC_DECIDE,filas()); VecSetFromOptions(W); VecAssemblyBegin(W); VecAssemblyEnd(W); return W; }

5.1.2.4.

Vec basicos::creaWn () [inline, inherited]

Se encarga de dimensionar el vector Wn para el sistema transitorio NOTA: El vector Wn es un vector generado con las funciones de la librería PETCs. Devuelve: Retorna un puntero a un vector PETCs Definición en la línea 137 del archivo estructuras.h. 138 139 140 141 142 143 144

{ VecCreate(PETSC_COMM_SELF,&Wn); VecSetSizes(Wn,PETSC_DECIDE,filas()); VecSetFromOptions(Wn); VecAssemblyBegin(Wn); VecAssemblyEnd(Wn); return Wn; }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.1

Generación de las variables del sistema matricial Tx=W

5.1.2.5.

Vec basicos::creaWn1 () [inline, inherited]

Se encarga de dimensionar el vector Wn1 para el sistema transitorio NOTA: El vector Wn1 es un vector generado con las funciones de la librería PETCs. Devuelve: Retorna un puntero a un vector PETCs Definición en la línea 151 del archivo estructuras.h. 152 153 154 155 156 157 158

{ VecCreate(PETSC_COMM_SELF,&Wn1); VecSetSizes(Wn1,PETSC_DECIDE,filas()); VecSetFromOptions(Wn1); VecAssemblyBegin(Wn1); VecAssemblyEnd(Wn1); return Wn1; }

5.1.2.6.

Vec basicos::creax_perm () [inline, inherited]

Se encarga de dimensionar el vector x para el sistema estacionario. En el se almacenan las soluciones del mismo. NOTA: El vector x_perm es un vector generado con las funciones de la librería PETCs. Devuelve: Retorna un puntero a un vector PETCs Definición en la línea 165 del archivo estructuras.h. 166 167 168 169 170 171 172

{ VecCreate(PETSC_COMM_SELF,&x_perm); VecSetSizes(x_perm,PETSC_DECIDE,filas()); VecSetFromOptions(x_perm); VecAssemblyBegin(x_perm); VecAssemblyEnd(x_perm); return x_perm; }

5.1.2.7.

Vec basicos::creax_trans () [inline, inherited]

Se encarga de dimensionar el vector x para el sistema transitorio. En el se almacenan las soluciones del mismo. NOTA: El vector x_trans es un vector generado con las funciones de la librería PETCs. Devuelve: Retorna un puntero a un vector PETCs Definición en la línea 179 del archivo estructuras.h. 180 181 182 183 184 185 186

{ VecCreate(PETSC_COMM_SELF,&x_trans); VecSetSizes(x_trans,PETSC_DECIDE,filas()); VecSetFromOptions(x_trans); VecAssemblyBegin(x_trans); VecAssemblyEnd(x_trans); return x_trans; }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.1

Generación de las variables del sistema matricial Tx=W

5.1.2.8.

void dimensiona (int ∗ num_line_total, basicos ∗ DATOS)

Se encarga de dimensionar la matriz T y el vector W para el posterior cálculo del sistema que nos proporcionará la solución del circuito. Tras calcular la dimensión de la misma se encarga de la creación de la T y W. Parámetros: num_line_total Esta variable contiene el número de líneas del fichero ∗.spc cargado que coincide con el número de elementos del circuito DATOS Puntero a estructura basicos Ver también: num_nodos(), num_elemA2(), num_EA() Definición en la línea 11 del archivo estructuras.cpp. 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

{ int maxnodo,numA2, numEA; Mat T; Vec W, Wn,Wn1; // PetscScalar v[1]; maxnodo = num_nodos (num_line_total, p_DATOS); p_DATOS->nodos=maxnodo; numA2 = num_elemA2 (num_line_total, p_DATOS); p_DATOS->A2=numA2; numEA = num_EA (num_line_total, p_DATOS); p_DATOS->EA=numEA; /*esta instruccion me da el valor donde ir colocando las EA que me encuentra al ir montando el sistema, según aparezcan iré incrementando este valor en 1*/ p_DATOS->apuntaEA=p_DATOS->situaEA(); /*Esta instrucción me da el valor donde debe ir el primer elemento que me encuentre perteneciente al grupo A2*/ p_DATOS->apuntaA2=p_DATOS->situaA2(); W=p_DATOS->creaW(); p_DATOS->W=W; T=p_DATOS->creaT(); p_DATOS->T=T; //Creación de Wn para transitorio Wn=p_DATOS->creaWn(); p_DATOS->Wn=Wn; Wn1=p_DATOS->creaWn1(); p_DATOS->Wn1=Wn1; }

5.1.2.9.

int num_EA (int ∗ num_line_total, basicos ∗ p_DATOS)

Calcula el número de elementos que se han considerado ecuación adicional. Para ello realiza un barrido por la qtable MDG sumando el número de ecuaciones adicionales existentes. Parámetros: num_line_total Esta variable contiene el número de líneas del fichero ∗.spc cargado que coincide con el número de elementos del circuito DATOS Puntero a estructura basicos Ver también: num_EA() Devuelve: Retorna el entero con el número de ecuaciones adicionales existentes en el circuito Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.1

Generación de las variables del sistema matricial Tx=W

Definición en la línea 82 del archivo estructuras.cpp. 83 { 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 }

5.1.2.10.

bool result; QString var_string, var_string2; int var=0, var2=0, numEA=0, num_extra=0,total=0; for(int i=0;i<=*num_line_total;i++) { //toma el valor EA para contar el nº de EA que tenemos var_string=p_DATOS->tableMDG->text(i,2); var= var_string.toInt(&result, 10); //Cuenta el número de Fuentes de V dep de I las cuales introducen 2 EA //Revisar si hay más elementos que introduzcan 2 EA var_string2=p_DATOS->tableMDG->text(i,0); var2= var_string2.toInt(&result, 10); if(var>0){numEA=numEA+1;} //if(var2==11||var2==7){num_extra=num_extra+1;} } total=numEA+num_extra; return total;

int num_elemA2 (int ∗, basicos ∗)

Calcula el número de elementos pertenecientes al grupo A2. Para ello realiza un barrido por la qtable MDG buscando los elementos del grupo A2. Parámetros: num_line_total Esta variable contiene el número de líneas del fichero ∗.spc cargado que coincide con el número de elementos del circuito DATOS Puntero a estructura basicos Ver también: num_elemA2() Devuelve: Retorna el entero con el número elementos del grupo A2 existente en el circuito Definición en la línea 64 del archivo estructuras.cpp. 65 { 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 }

bool result; QString var_string, var2_string; int var=0, var2=0, numA2=0; for(int i=0;i<*num_line_total;i++) { var_string=p_DATOS->tableMDG->text(i,3); var2_string=p_DATOS->tableMDG->text(i,0); var= var_string.toInt(&result, 10); var2=var2_string.toInt(&result, 10); if(var==2){numA2=numA2+1;} if(var2==7 ||var2==11 || var2==12 || var2==15){numA2=numA2+1;} } return numA2;

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

5.1.2.11.

int num_nodos (int ∗ num_line_total, basicos ∗ p_DATOS)

Calcula el número de nodos del circuito. Para ello realiza un barrido por la qtable MN buscando el mayor valor introducido. Parámetros: num_line_total Esta variable contiene el número de líneas del fichero ∗.spc cargado que coincide con el número de elementos del circuito DATOS Puntero a estructura basicos Ver también: num_nodos() Devuelve: Retorna el entero con el número de nodos existente en el circuito Definición en la línea 47 del archivo estructuras.cpp. 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

{ bool result; QString var_string; int var=0, maxnodo=0; for(int i=0;i<*num_line_total;i++) { for(int j=0;j<4;j++) { var_string=p_DATOS->tableMN->text(i,j); var=var_string.toInt(&result,10); if(var>maxnodo) {maxnodo=var;} } } return maxnodo; }

5.2.

Forma de cargar los distintos elementos que componen un circuito

Diagrama de colaboración para Forma de cargar los distintos elementos que componen un circuito: Creación del sistema general de ecuaciones lineales

Forma de cargar los distintos elementos que componen un circuito

Este conjunto de funciones se encarga de indicar los límites del vector del elemento que se carga en las Qtable: MDG, MN y MVC. El grupo de funciones lee_elementoX envía los límites del vector que los define para un correcto tratamiento de los datos de los elementos de un circuito. De esta forma se pueden generar nuevos elementos de manera más sencilla y sin limitaciones en los parámetros de definición. Para más información leer manual de funcionamiento de Ávalon. Funciones void lee_elemento (int elemento, basicos ∗p_DATA) Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

void lee_conductancia (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una conductancia.

void lee_resistencia (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una resistencia.

void lee_condensador (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una condensador.

void lee_bobina (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una bobina.

void lee_fuenteVcc (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una fuente de tensión.

void lee_fuenteI (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una fuente de corriente.

void lee_ampl0 (basicos ∗p_DATA) Esta función se encarga de detectar los límites de un amplificador operacional.

void lee_trafo (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una transformador.

void lee_FuenIdepV (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una fuente de intensidad dependiente de tensión.

void lee_FuenVdepV (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una fuente de tensión dependiente de tensión.

void lee_FuenIdepI (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una fuente de intensidad dependiente de intensidad.

void lee_FuenVdepI (basicos ∗p_DATA) Esta función se encarga de detectar los límites de una fuente de tensión dependiente de corriente.

void lee_bobAcopl (basicos ∗p_DATA) Esta función se encarga de detectar los límites de bobinas acopladas.

void lee_interruptor (basicos ∗p_DATA) Esta función se encarga de detectar los límites de un interruptor.

void lee_cuatripoloadmitancia (basicos ∗p_DATA) Esta función se encarga de detectar los límites de un Cuatripolo con parámetros de admitancia.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

void lee_cuatripoloimpedancia (basicos ∗p_DATA) Esta función se encarga de detectar los límites de un Cuatripolo con parámetros de impedancia.

void lee_cuatripolohibrido (basicos ∗p_DATA) Esta función se encarga de detectar los límites de un Cuatripolo con parámetros híbridos.

void lee_cuatripolotransmision (basicos ∗p_DATA) Esta función se encarga de detectar los límites de un Cuatripolo con parámetros de trasmisión.

void actualiza (basicos ∗DATOS) Actualiza es una función que se encarga de mostrar por shell parámetros de interés en el análisis de un circuito. En realidad se encarga de mostrar elementos del objeto DATOS de la estructura basicos.

5.2.1.

Descripción detallada

Documentación de las funciones void actualiza (basicos ∗ DATOS)

Actualiza es una función que se encarga de mostrar por shell parámetros de interés en el análisis de un circuito. En realidad se encarga de mostrar elementos del objeto DATOS de la estructura basicos. Parámetros: DATOS Puntero a estructura basicos Definición en la línea 116 del archivo estructuras.cpp. 117 { 118 QString 119 120 121 122 123 124 125 126 127

line; cout << cout << cout << cout << cout << cout << cout << cout << cout <<

"\nContenido de la estructura DATOS: "<<endl; "Número de elementos: "<<DATOS->elementos<<endl; "Número de EA: "<<DATOS->EA<<endl; "Número de nodos: "<<DATOS->nodos<<endl; "Número de elementos en grupo A2: "<<DATOS->A2<<"\n"; "Elementos NO nulos: "<<DATOS->nocero<<endl; "Densidad: "<<DATOS->densidad<<endl; "Dispersión: "<<DATOS->dispersion<<endl; "Tiempo Inicial: "<<DATOS->t0<<"\t";

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

128 129 130 131 }

5.2.2.2.

cout << "Tiempo Final: "<<DATOS->tf<<"\t"; cout << "Paso de Tiempo: "<<DATOS->h<<"\t"; cout << "Theta: "<<DATOS->theta<<"\n";

void lee_ampl0 (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de un amplificador operacional. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 538 del archivo estructuras.cpp. 539 { 540 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=9; 541 }

5.2.2.3.

void lee_bobAcopl (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de bobinas acopladas. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 562 del archivo estructuras.cpp. 563 { 564 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=17; 565 }

5.2.2.4.

void lee_bobina (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una bobina. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 526 del archivo estructuras.cpp. 527 { 528 p_DATA->lim[0]=4;p_DATA->lim[1]=6;p_DATA->lim[2]=8; 529 }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

5.2.2.5.

void lee_condensador (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una condensador. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 522 del archivo estructuras.cpp. 523 { 524 p_DATA->lim[0]=4;p_DATA->lim[1]=6;p_DATA->lim[2]=8; 525 }

5.2.2.6.

void lee_conductancia (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una conductancia. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 514 del archivo estructuras.cpp. 515 { 516 p_DATA->lim[0]=4;p_DATA->lim[1]=6;p_DATA->lim[2]=8; 517 }

5.2.2.7.

void lee_cuatripoloadmitancia (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de un Cuatripolo con parámetros de admitancia. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 570 del archivo estructuras.cpp. 571 { 572 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=18; 573 }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

5.2.2.8.

void lee_cuatripolohibrido (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de un Cuatripolo con parámetros híbridos. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 578 del archivo estructuras.cpp. 579 { 580 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=18; 581 }

5.2.2.9.

void lee_cuatripoloimpedancia (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de un Cuatripolo con parámetros de impedancia. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 574 del archivo estructuras.cpp. 575 { 576 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=18; 577 }

5.2.2.10.

void lee_cuatripolotransmision (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de un Cuatripolo con parámetros de trasmisión. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 582 del archivo estructuras.cpp. 583 { 584 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=18; 585 }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

5.2.2.11.

void lee_elemento (int elemento, basicos ∗ p_DATA)

Esta Función se encarga de ver que elemento estamos analizando y llamar a funciones específicas para el tratamiento en cuestión del elemento. Concretamente llama a las funciones lee_elementoX para poder asignar los límites de las tablas en las que se cargan los valores que definen a los elementos del circuito que se este analizando. Parámetros: elemento ID del elemento que se esta cargando p_DATA Puntero a estructura basicos Ver también: bcl_principal::slt_abrirspc() Definición en la línea 486 del archivo estructuras.cpp. 487 { 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 }

5.2.2.12.

switch (elemento) { case 0: lee_conductancia(p_DATA);break; case 1: lee_resistencia(p_DATA);break; case 2: lee_condensador(p_DATA);break; case 3: lee_bobina(p_DATA);break; case 4: lee_fuenteVcc(p_DATA);break; case 5: lee_fuenteI(p_DATA);break; case 6: lee_ampl0(p_DATA);break; case 7: lee_trafo(p_DATA);break; case 8: lee_FuenIdepV(p_DATA);break; case 9: lee_FuenVdepV(p_DATA);break; case 10: lee_FuenIdepI(p_DATA);break; case 11: lee_FuenVdepI(p_DATA);break; case 12: lee_bobAcopl(p_DATA);break; case 13: lee_interruptor(p_DATA);break; case 14: lee_cuatripoloadmitancia(p_DATA);break; case 15: lee_cuatripoloimpedancia(p_DATA);break; case 16: lee_cuatripolohibrido(p_DATA);break; case 17: lee_cuatripolotransmision(p_DATA);break; case 18: cout<<"\n ERROR Asegúrese de que la librería está adaptada a Ávalon"<<endl; break; }

void lee_FuenIdepI (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una fuente de intensidad dependiente de intensidad. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 554 del archivo estructuras.cpp. 555 { 556 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=10; 557 }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

5.2.2.13.

void lee_FuenIdepV (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una fuente de intensidad dependiente de tensión. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 546 del archivo estructuras.cpp. 547 { 548 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=10; 549 }

5.2.2.14.

void lee_fuenteI (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una fuente de corriente. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 534 del archivo estructuras.cpp. 535 { 536 p_DATA->lim[0]=4;p_DATA->lim[1]=6;p_DATA->lim[2]=16; 537 }

5.2.2.15.

void lee_fuenteVcc (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una fuente de tensión. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 530 del archivo estructuras.cpp. 531 { 532 p_DATA->lim[0]=4;p_DATA->lim[1]=6;p_DATA->lim[2]=16; 533 }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.2

Forma de cargar los distintos elementos que componen un circuito

5.2.2.16.

void lee_FuenVdepI (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una fuente de tensión dependiente de corriente. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 558 del archivo estructuras.cpp. 559 { 560 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=10; 561 }

5.2.2.17.

void lee_FuenVdepV (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una fuente de tensión dependiente de tensión. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 550 del archivo estructuras.cpp. 551 { 552 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=10; 553 }

5.2.2.18.

void lee_interruptor (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de un interruptor. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 566 del archivo estructuras.cpp. 567 { 568 p_DATA->lim[0]=4;p_DATA->lim[1]=6;p_DATA->lim[2]=8; 569 }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.3

Métodos de resolución

5.2.2.19.

void lee_resistencia (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una resistencia. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 518 del archivo estructuras.cpp. 519 { 520 p_DATA->lim[0]=4;p_DATA->lim[1]=6;p_DATA->lim[2]=8; 521 }

5.2.2.20.

void lee_trafo (basicos ∗ p_DATA)

Esta función se encarga de detectar los límites de una transformador. Parámetros: p_DATA Puntero a estructura basicos. Ver también: designer Definición en la línea 542 del archivo estructuras.cpp. 543 { 544 p_DATA->lim[0]=4;p_DATA->lim[1]=8;p_DATA->lim[2]=10; 545 }

5.3.

Métodos de resolución

Diagrama de colaboración para Métodos de resolución: Resolución de Transitorio

Métodos de resolución

Resultados

Resolución de Permanente

Módulos Resolución de Permanente Resolución de Transitorio Resultados

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.3

Métodos de resolución

Slots públicos virtual void sbcl_principal::slt_resolver () El slot resolver se encarga comenzar los procesos necesarios para la resolución del sistema.

Slots protegidos virtual void sbcl_principal::slt_resolucion (basicos ∗p_DATOS) Este Slot se encarga de seguir el proceso de resolución de los sistemas de ecuaciones del circuito a analizar.

5.3.1.

Descripción detallada

En este grupo de funciones se encuentran todas aquellas que hacen posible la resolución de los sistemas estacionarios y transitorios 5.3.2.

Slots públicos

5.3.2.1.

void sbcl_principal::slt_resolver () [virtual, slot, inherited]

El slot resolver se encarga comenzar los procesos necesarios para la resolución del sistema. Entre las tareas que realiza esta función se encuentra: Ver si la matriz T está ensamblada Toma los valores de análisis del transitorio, tiempo inicial, final, paso de tiempo y valor de theta. Leer los valores existentes en las tablas MDG, MN y MVC Ver también: actualiza, slt_resolucion Parámetros: p_DATOS Puntero a estructura basicos Ver también: resolucion_transitorio, resolucion_permanente Chequea que ha elegido el usuario para llamar a las funciones resolucion_transitorio o resolucion_permanente. Además también se encarga de llamar a las funciones que cargan en pantalla los sistemas utilizados y sus respectivas soluciones Definición en la línea 234 del archivo sbcl_principal.cpp. 235 236 237 238 239 240

{ basicos *p_DATOS;basicos *p_DATA; p_DATA=&DATOS; p_DATOS=&DATOS; int i,j,k,cont=0; int *ii=&i; int *jj=&j,*p_cont=&cont;

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.3

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307

Métodos de resolución

int element; bool result; p_DATOS->estaT=0;//cargamos a 0 para indicar que no está ensamblada la matriz T //cargamos los valores para el transitorio QString h; h=lineEdit_t0->text(); p_DATOS->t0=h.toDouble(&result); h=lineEdit_tf->text(); p_DATOS->tf=h.toDouble(&result); h=lineEdit_h->text(); p_DATOS->h=h.toDouble(&result); h=lineEdit_theta->text(); p_DATOS->theta=h.toDouble(&result); //Barremos las tablas para resolver el estacionario if(p_DATOS->estacionario==1){ for(i=0;i<DATOS.elementos;i++) { /*declaración del vector que contiene los datos leidos de las diferentes Qtables la longitud debe ser la del elemento más largo*/ double elemento[16]; //limpiamos en vector elemento for(j=0;j<16;j++){elemento[j]=0;} element=filaTable (ii,p_cont,tableMDG); lee_elemento (element,p_DATA); for(j=0;j<p_DATA->lim[2];j++) { ii=&i;jj=&j; if(j<p_DATA->lim[0]) {elemento[j]=filaTable (ii,jj,p_DATOS->tableMDG);} int a=(j-p_DATA->lim[0]);jj=&a; if (j<p_DATA->lim[1] && j>=p_DATA->lim[0]) {elemento[j]=filaTable (ii,jj,p_DATOS->tableMN);} int b=(j-p_DATA->lim[1]);jj=&b; if(j<p_DATA->lim[2] && j>=p_DATA->lim[1]) {elemento[j]=filaTable (ii,jj,p_DATOS->tableMVC);} } double *p_elemento=&elemento[0]; p_DATOS->t=0; elementoMatrizT(p_elemento,p_DATOS); elementoVectorW(p_elemento,p_DATOS,p_DATOS->t); } //llamada a salida de datos slt_resolucion(p_DATOS); p_DATOS->estacionario=0; } //REsolución del transitorio if(p_DATOS->transitorio==1) { //Creamos el Vector que guardará la solución del sistema estacionario p_DATOS->x_trans=p_DATOS->creax_trans(); //calculo del número de iteraciones if(p_DATOS->t0 > p_DATOS->tf){p_DATOS->numv=0; cout<<"Error los datos necesarios para el transitorio están mal"<<endl;} else {num_iteraciones(p_DATOS);} if(p_DATOS->numv!=0)//Entra sólo si las iteraciones a realizar son diferentes a 0 { for(k=1;k<=p_DATOS->numv;k++)//Este for da tantas vueltas como número de iteraciones { p_DATOS->iter=k; //iMPORTANTE para que se apunte a EA y A2 p_DATOS->apuntaA2=p_DATOS->situaA2();p_DATOS->apuntaEA=p_DATOS->situaEA(); for(i=0;i<DATOS.elementos;i++) { /*declaración del vector que contiene los datos leidos de las diferentes Qtables la longitud debe ser la del elemento más largo*/ double elemento[16]; //limpiamos en vector elemento for(j=0;j<16;j++){elemento[j]=0;} element=filaTable (ii,p_cont,tableMDG); lee_elemento (element,p_DATA);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.3

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374

Métodos de resolución

for(j=0;j<p_DATA->lim[2];j++) { ii=&i;jj=&j; if(j<p_DATA->lim[0]) {elemento[j]=filaTable (ii,jj,p_DATOS->tableMDG);} int a=(j-p_DATA->lim[0]);jj=&a; if (j<p_DATA->lim[1] && j>=p_DATA->lim[0]) {elemento[j]=filaTable (ii,jj,p_DATOS->tableMN);} int b=(j-p_DATA->lim[1]);jj=&b; if(j<p_DATA->lim[2] && j>=p_DATA->lim[1]) {elemento[j]=filaTable (ii,jj,p_DATOS->tableMVC);} } double *p_elemento=&elemento[0]; p_DATOS->t=k-1; if(p_DATOS->estaT==1) { elementoVectorW(p_elemento,p_DATOS,p_DATOS->t); } else { elementoMatrizT(p_elemento,p_DATOS); elementoVectorW(p_elemento,p_DATOS,p_DATOS->t); } } MatAssemblyBegin(p_DATOS->T,MAT_FINAL_ASSEMBLY); MatAssemblyEnd(p_DATOS->T,MAT_FINAL_ASSEMBLY); p_DATOS->estaT=1; VecAssemblyBegin(p_DATOS->W); VecAssemblyEnd(p_DATOS->W); //preparando el sistema transitorio PetscTruth *flg; Mat A1; Vec BBCC,z; z=creavectorauxiliar(p_DATOS); VecCreate(PETSC_COMM_SELF,&BBCC); VecSetSizes(BBCC,PETSC_DECIDE,p_DATOS->filas());VecSetFromOptions(BBCC); VecAssemblyBegin(BBCC); VecAssemblyEnd(BBCC); p_DATOS->BBCC=BBCC; MatCreateSeqAIJ(PETSC_COMM_SELF,p_DATOS->filas(),p_DATOS->columnas(),10,PETSC_NULL,&A1); MatAssemblyBegin(A1,MAT_FINAL_ASSEMBLY);MatAssemblyEnd(A1,MAT_FINAL_ASSEMBLY); PetscScalar unomenostheta=1-p_DATOS->theta; PetscScalar thetamenosuno=p_DATOS->theta-1; p_DATOS->creaGC(); MatCopy(p_DATOS->T,p_DATOS->G, DIFFERENT_NONZERO_PATTERN); MatCopy(p_DATOS->T,p_DATOS->C, DIFFERENT_NONZERO_PATTERN); MatImaginaryPart(p_DATOS->C); float unoentreh=1/p_DATOS->h; MatScale ( p_DATOS->C, unoentreh); MatRealPart(p_DATOS->G); MatCopy(p_DATOS->G,A1, DIFFERENT_NONZERO_PATTERN); MatAYPX(p_DATOS->G,p_DATOS->theta,p_DATOS->C, DIFFERENT_NONZERO_PATTERN); //Operación A realizada Y = a*Y + X. MatAYPX(Mat Y,PetscScalar a,Mat X,MatStructure str) //A1=(theta-1)*G+C/h Operación B realizada MatAYPX(A1,thetamenosuno,p_DATOS->C, DIFFERENT_NONZERO_PATTERN); p_DATOS->x0=p_DATOS->creax0(k,p_DATOS);//Creamos el vector de condiciones iniciales VecScale (p_DATOS->Wn1, p_DATOS->theta); //preparación de CC y DD VecScale (p_DATOS->Wn, unomenostheta); //VecWAXPY(Vec w,PetscScalar alpha,Vec x,Vec y) Computes w = alpha x + y. VecWAXPY(z,1,p_DATOS->Wn,p_DATOS->Wn1); //MatMultAdd(Mat mat,Vec v1,Vec v2,Vec v3) Computes v3 = v2 + A * v1,prepara BB+CC MatMultAdd(A1,p_DATOS->x0,z,BBCC); //MatMultAdd(BBCC,Vec1,p_DATOS->W,terminoIndep); //Resolucion resolucion_transitorio(p_DATOS); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.4

Resolución de Permanente

375 376 377 378 379 380

} escribirgnuplot(p_DATOS); //llamada a salida de datos slt_resolucion(p_DATOS); } }

5.3.3.

Slots protegidos

5.3.3.1. void sbcl_principal::slt_resolucion (basicos ∗ p_DATOS) [protected, virtual, slot, inherited] Este Slot se encarga de seguir el proceso de resolución de los sistemas de ecuaciones del circuito a analizar. Parámetros: p_DATOS Puntero a estructura basicos Definición en la línea 427 del archivo sbcl_principal.cpp. 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444

{ if(p_DATOS->estaT!=1) { MatAssemblyBegin(p_DATOS->T,MAT_FINAL_ASSEMBLY);MatAssemblyEnd(p_DATOS->T,MAT_FINAL_ASSEMBLY); p_DATOS->estaT=1; } VecAssemblyBegin(p_DATOS->W); VecAssemblyEnd(p_DATOS->W); if(p_DATOS->transitorio==1){resolucion_transitorio(p_DATOS);} if(p_DATOS->estacionario==1){resolucion_permanente(p_DATOS);} mostrar_solucion(p_DATOS); //CArgar soluciones en pantalla slt_sistemaestacionario(); slt_sistematransitorio(); slt_solucionestacionario(); slt_soluciontransitorio(); INFOgeneral (p_DATOS); }

5.4.

Resolución de Permanente

Diagrama de colaboración para Resolución de Permanente: Métodos de resolución

Resolución de Permanente

Funciones int resolucion_permanente (basicos ∗p_DATOS) Función que se encarga de la resolución del sistema permanente del circuito a analizar.

5.4.1.

Descripción detallada

Grupo encargado de la resolución del sistema permanente del circuito que se esté analizando

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.5

Resolución de Transitorio

5.4.2.

Documentación de las funciones

5.4.2.1.

int resolucion_permanente (basicos ∗ p_DATOS)

Función que se encarga de la resolución del sistema permanente del circuito a analizar. Parámetros: Puntero a estructura basicos Definición en la línea 135 del archivo estructuras.cpp. 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167

5.5.

{ Vec X,W; Mat T; PetscErrorCode ierr; KSP ksp; PetscViewer viewer, escribeDATOS; //Creamos el Vector que guardará la solución del sistema estacionario p_DATOS->x_perm=p_DATOS->creax_perm(); VecAssemblyBegin(p_DATOS->x_perm); VecAssemblyEnd(p_DATOS->x_perm); //Cargamos los parametros de preacondicionamiento PetscOptionsInsertFile("opciones.txt"); ierr = KSPCreate(PETSC_COMM_WORLD,&ksp);CHKERRQ(ierr); //Copias de los elementos con los que trabajaremos T,W y X T=p_DATOS->T; W=p_DATOS->W; X=p_DATOS->x_perm; //Resolución del sistema lineal ierr = KSPSetOperators(ksp,T,T,DIFFERENT_NONZERO_PATTERN);CHKERRQ(ierr); KSPSetFromOptions(ksp); ierr = KSPSolve(ksp,W,X);CHKERRQ(ierr); //llamada a funcion que excriba los valores del sistema PetscViewerASCIIOpen(PETSC_COMM_WORLD, "Datos_x_perm.data", &escribeDATOS); MatView(p_DATOS->T, escribeDATOS); VecView(p_DATOS->W, escribeDATOS); //Volcado del resultado en la Estructura DATOS BASICOS p_DATOS->x_perm=X; ierr = MatDestroy(T);CHKERRQ(ierr); ierr = VecDestroy(W);CHKERRQ(ierr); ierr = VecDestroy(X);CHKERRQ(ierr); //Escritura de la solución en fichero PetscViewerASCIIOpen(PETSC_COMM_WORLD, "x_perm.data", &viewer); VecView(p_DATOS->x_perm, viewer); return 0; }

Resolución de Transitorio

Diagrama de colaboración para Resolución de Transitorio: Métodos de resolución

Resolución de Transitorio

Funciones Vec creavectorauxiliar (basicos ∗p_DATOS) Función que se encarga crear un vector auxiliar de cálculo del sistema a resolver.

void num_iteraciones (basicos ∗p_DATOS)

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.5

Resolución de Transitorio

Función que se encarga calcular el número de iteraciones necesarias en el método iterativo directo utilizado.

int resolucion_transitorio (basicos ∗p_DATOS) Función que se encarga de la resolución del sistema permanente del circuito a analizar.

5.5.1.

Descripción detallada

Grupo encargado de la resolución del sistema transitorio del circuito que se esté analizando 5.5.2. 5.5.2.1.

Documentación de las funciones Vec creavectorauxiliar (basicos ∗ p_DATOS)

Función que se encarga crear un vector auxiliar de cálculo del sistema a resolver. Parámetros: Puntero a estructura basicos return Vector tipo PETSc Definición en la línea 37 del archivo estructuras.cpp. 38 39 40 41 42 43 44 45

{ Vec z; VecCreate(PETSC_COMM_SELF,&z); VecSetSizes(z,PETSC_DECIDE,p_DATOS->filas()); VecSetFromOptions(z); VecAssemblyBegin(z); VecAssemblyEnd(z); return z; }

5.5.2.2.

void num_iteraciones (basicos ∗ p_DATOS)

Función que se encarga calcular el número de iteraciones necesarias en el método iterativo directo utilizado. Parámetros: Puntero a estructura basicos Definición en la línea 170 del archivo estructuras.cpp. 171 { 172 p_DATOS->numv=(p_DATOS->tf-p_DATOS->t0)/p_DATOS->h; 173 174 }

5.5.2.3.

int resolucion_transitorio (basicos ∗ p_DATOS)

Función que se encarga de la resolución del sistema permanente del circuito a analizar. Parámetros: Puntero a estructura basicos Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.6

Resultados

Definición en la línea 177 del archivo estructuras.cpp. 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198

{ Vec BBCC=p_DATOS->BBCC; KSP ksp; PetscOptionsInsertFile("opciones.txt"); KSPCreate(PETSC_COMM_WORLD,&ksp); KSPSetOperators(ksp,p_DATOS->G,p_DATOS->G,DIFFERENT_NONZERO_PATTERN); KSPSetFromOptions(ksp); //llamada a funcion que excriba los valores del sistema PetscViewer escribeDATOStran; PetscViewerASCIIOpen(PETSC_COMM_WORLD, "Datos_x_trans.data", &escribeDATOStran); MatView(p_DATOS->G, escribeDATOStran); VecView(BBCC, escribeDATOStran); KSPSolve(ksp,BBCC,p_DATOS->x_trans);//KSPSolve(KSP ksp,Vec b,Vec x) PetscViewer viewer; PetscViewerSetFormat(viewer,PETSC_VIEWER_ASCII_COMMON ); PetscViewerASCIIOpen(PETSC_COMM_WORLD, "x_trans.data", &viewer); VecView(p_DATOS->x_trans, viewer); p_DATOS->Wn=p_DATOS->creaWn(); p_DATOS->Wn1=p_DATOS->creaWn1(); return 0; }

5.6.

Resultados

Diagrama de colaboración para Resultados: Métodos de resolución

Resultados

Funciones int mostrar_solucion (basicos ∗p_DATOS) Función que se encarga de preparar los ficheros que se mostrarán por pantalla.

QString queescribo (QString escribir) Función que se encarga de complementar a mostrar_solucion para escribir el tipo de elemento del que se está tomando la variable Esta función, dependiendo de que elemento, retorna un QString con el nombre del mismo para poder escribirlo en el fichero de soluciones.

void escribirgnuplot (basicos ∗p_DATOS) Función que se encarga de crear el script que usará el GNUPlot para graficar la solución del transitorio.

int mostrar_CI (basicos ∗p_DATOS) Función que se encarga de identificar e indicar en la interfaz que representa cada Condición Inicial que debe ser introducida al realizar un análisis transitorio.

QString script (basicos ∗p_DATOS) Función que se abrir el script para que el usuario pueda modificarlo y adaptarlo a sus necesidades.

5.6.1.

Descripción detallada

Grupo encargado de la preparación de los resultados de ambos sistemas Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.6

Resultados

5.6.2. 5.6.2.1.

Documentación de las funciones void escribirgnuplot (basicos ∗ p_DATOS)

Función que se encarga de crear el script que usará el GNUPlot para graficar la solución del transitorio. Parámetros: Puntero a estructura basicos Ver también: sbcl_principal::slt_xcircuit() Variando esta función se pueden obtener los scripts que más se adecúen a las necesidades del usuario. Ávalon permite la modificación del script generado por defecto a través de la interfaz de salida Definición en la línea 587 del archivo estructuras.cpp. 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632

{ QString dire =p_DATOS->datos_trans; fstream fich(dire, ios::in |ios::out | ios::trunc | ios::binary); char texto[100]; ifstream fichero; // Abro para lectura fichero.open("x_trans.data"); float contador=p_DATOS->t0;; if (!fichero) { cout << "No se ha podido abrir el fichero." << endl; exit(1); } fichero.get(texto,256); for (int indice=0; indice<=(p_DATOS->filas()*p_DATOS->numv)+1; indice++) { fich<<texto<<" "; fichero.getline(texto,256); if(0==indice%p_DATOS->filas() && indice!=0 && indice!=p_DATOS->filas()*p_DATOS->numv) {fich<<" "<<contador<<" \n";contador=contador+p_DATOS->h;} } fichero.close(); fich.close(); //Ploteando las soluciones fstream ploteo(p_DATOS->datos_script, ios::in |ios::out | ios::trunc | ios::binary); ifstream variable; variable.open("variables.data"); if (!variable) { cout << "No se ha podido abrir el fichero." << endl; exit(1); } variable.getline(texto,255); int numcol=p_DATOS->filas()+1; ploteo<<"set terminal png "<<endl; QString grafica = p_DATOS->solucion; ploteo<<"set output ’"<<grafica<<"’"<<endl; ploteo<<"set encoding iso_8859_1\nset grid\n"<< "set autoscale\nset key bottom right title ’Variables’ box"<<endl; ploteo<<"set title ’Graficado por defecto de las soluciones del circuito’"<<endl; ploteo<<"plot "; for(int graf=numcol;graf>1;graf--)

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.6

633 634 635 636 637 638 639 640 641 642 643 644 645

Resultados

{ ploteo<<"’"<<dire<<"’ using "<<numcol<<":"<<numcol-graf+1<< " title ’"<<texto<<"’"<<" with lines"; variable.getline(texto,255); if(numcol-graf+1!=numcol-1){ploteo<<", ";} } ploteo<<"\n"<<endl; variable.close(); ploteo.close(); QString plotear = p_DATOS->datos_script; plotear.prepend("gnuplot "); system (plotear); }

5.6.2.2.

int mostrar_CI (basicos ∗ p_DATOS)

Función que se encarga de identificar e indicar en la interfaz que representa cada Condición Inicial que debe ser introducida al realizar un análisis transitorio. Parámetros: Puntero a estructura basicos Con esta función se puede saber que es cada variable que solicita el programa antes de realizar un análisis transitorio. Se debe tener presente que las condiciones iniciales deben ser consistentes. Definición en la línea 647 del archivo estructuras.cpp. 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682

{ PetscViewer viewer; PetscScalar DATO; PetscViewerASCIIOpen(PETSC_COMM_WORLD, "CI.data", &viewer); PetscViewerDestroy(viewer); fstream fich("CI.data", ios::in |ios::out | ios::trunc | ios::binary); for (int i=0; i<p_DATOS->nodos; i++) { fich<<"V nodo "<<i+1<<endl; } QString esA2, esEA, elemento, nodoi, nodoj, nodom, nodon; for(int j=0; j<p_DATOS->elementos;j++) { esA2=p_DATOS->tableMDG->text(j,3); esEA=p_DATOS->tableMDG->text(j,2); elemento=p_DATOS->tableMDG->text(j,0); nodoi=p_DATOS->tableMN->text(j,0); nodoj=p_DATOS->tableMN->text(j,1); nodom=p_DATOS->tableMN->text(j,2); nodon=p_DATOS->tableMN->text(j,3); if (esA2=="2") { if(elemento=="1") {fich<<"I if(elemento=="3") {fich<<"I if(elemento=="4") {fich<<"I if(elemento=="6") {fich<<"I if(elemento=="7") {fich<<"I fich<<"I

Resistencia entre nodos "<<nodoi<<", "<<nodoj<<endl;} Bobina entre nodos "<<nodoi<<", "<<nodoj<<endl;} Fuente tension entre nodos "<<nodoi<<", "<<nodoj<<endl;} Amplificador entre nodos "<<nodoi<<", "<<nodoj<<endl;} Trafo entre nodos "<<nodoi<<", "<<nodoj<<endl; Trafo entre nodos "<<nodom<<", "<<nodon<<endl;}

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.6

683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722

Resultados

if(elemento=="9") {fich<<"I Fuente de V dependiente de V entre nodos "<<nodoi<<", "<<nodoj<<endl;} if(elemento=="10") {fich<<"I Fuente de I dependiente de I entre nodos "<<nodoi<<", "<<nodoj<<endl;} if(elemento=="11") {fich<<"I Fuente de V dependiente de I entre nodos "<<nodoi<<", "<<nodoj<<endl; fich<<"I Fuente de V dependiente de I entre nodos "<<nodom<<", "<<nodon<<endl;} if(elemento=="12") {fich<<"I Bobinas Acopladas entre nodos "<<nodoi<<", "<<nodoj<<endl; fich<<"I Bobinas Acopladas entre nodos "<<nodom<<", "<<nodon<<endl;} if(elemento=="13") {fich<<"I que recorre el Interruptor entre nodos "<<nodoi<<", "<<endl;} if(elemento=="15") {fich<<"I Cuatripolo en Z entre nodos "<<nodoi<<", "<<nodoj<<endl; fich<<"I Cuatripolo en Z entre nodos "<<nodom<<", "<<nodon<<endl;} if(elemento=="16") {fich<<"I Cuatripolo en h entre nodos "<<nodoi<<", "<<nodoj<<endl;} if(elemento=="17") {fich<<"I Cuatripolo en r entre nodos "<<nodoi<<", "<<nodoj<<endl;} } if (esA2=="1") { if(esEA=="1") { if(esEA=="1") { if(elemento=="0") {fich<<"Intensidad de "<<queescribo(p_DATOS->tableMDG->text(j,0))<< " entre nodos "<<nodoi<<", "<<nodoj<<endl;} if(elemento=="2") {fich<<"Intensidad de "<<queescribo(p_DATOS->tableMDG->text(j,0))<< " entre nodos "<<nodoi<<", "<<nodoj<<endl;} if(elemento=="8") {fich<<"I de Fuente de I dependiente de V entre nodos "<<nodom<< ", "<<nodon<<endl;} } } } } }

5.6.2.3.

int mostrar_solucion (basicos ∗ p_DATOS)

Función que se encarga de preparar los ficheros que se mostrarán por pantalla. Parámetros: Puntero a estructura basicos Esta función prepara los ficheros siguientes: Archivo donde se vuelcan los resultados del sistema estacionario identificando cada una de las variables utilizadas Archivo Variables en el cual se apoya la función de generación de script para gnuplot Ver también: escribirgnuplot Definición en la línea 200 del archivo estructuras.cpp.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.6

201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267

Resultados

{ PetscViewer viewer; PetscScalar DATO; if(p_DATOS->estacionario==1) { QString dire=p_DATOS->datos_perm; PetscViewerASCIIOpen(PETSC_COMM_WORLD, dire, &viewer); PetscViewerDestroy(viewer); fstream fich(dire, ios::in |ios::out | ios::trunc | ios::binary); char texto[100]; ifstream fichero; // Abro para lectura fichero.open("x_perm.data"); if (!fichero) { cout << "No se ha podido abrir el fichero."<< endl; exit(1); } fichero.getline(texto,256); //fichero >> texto; fich<<"Resultados sistema estacionario: \n"<<endl; for (int i=0; i<p_DATOS->nodos; i++) { fich<<"Tensión en nodo "<<i+1<<": "<<texto<<endl; fichero.getline(texto,256); } QString esA2, esEA, elemento, nodoi, nodoj, nodom, nodon; for(int j=0; j<p_DATOS->elementos;j++) { esA2=p_DATOS->tableMDG->text(j,3); esEA=p_DATOS->tableMDG->text(j,2); elemento=p_DATOS->tableMDG->text(j,0); nodoi=p_DATOS->tableMN->text(j,0); nodoj=p_DATOS->tableMN->text(j,1); nodom=p_DATOS->tableMN->text(j,2); nodon=p_DATOS->tableMN->text(j,3); if (esA2=="2") { if(elemento=="1") {fich<<"I Resistencia entre nodos "<<nodoi<<", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="3") {fich<<"I de Bobina entre nodos "<<nodoi<<", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="4") {fich<<"I de Fuente tension entre nodos "<<nodoi<<", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="6") {fich<<"I de Amplificador entre nodos "<<nodoi<<", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="7") {fich<<"I de Trafo entre nodos "<<nodoi<<", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256); fich<<"I de Trafo entre nodos "<<nodom<<", "<<nodon<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="9") {fich<<"I de Fuente de V dependiente de V entre nodos "<<nodoi<< ", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="10") {fich<<"I de Fuente de I dependiente de I entre nodos "<<nodoi<< ", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="11") {fich<<"I de Fuente de V dependiente de I entre nodos "<<nodoi<<

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.6

268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334

Resultados

", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256); fich<<"I de Fuente de V dependiente de I entre nodos "<<nodom<< ", "<<nodon<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="12") {fich<<"I de Bobinas Acopladas entre nodos "<<nodoi<< ", "<<nodoj<<": "<<texto<<endl; fichero.getline(texto,256); fich<<"I de Bobinas Acopladas entre nodos "<<nodom<<", "<< nodon<<": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="13") {fich<<"I que recorre el Interruptor entre nodos "<<nodoi<< ", "<<nodoj<<"\n"; fichero.getline(texto,256);} if(elemento=="15") {fich<<"I de Cuatripolo en Z entre nodos "<<nodoi<<", "<<nodoj<< ": "<<texto<<endl; fichero.getline(texto,256); fich<<"I de Cuatripolo en Z entre nodos "<<nodom<<", "<<nodon<< ": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="16") {fich<<"I de Cuatripolo en h entre nodos "<<nodoi<<", "<<nodoj<< ": "<<texto<<endl; fichero.getline(texto,256);} if(elemento=="17") {fich<<"I de Cuatripolo en r entre nodos "<<nodoi<<", "<<nodoj<< ": "<<texto<<endl; fichero.getline(texto,256);} } if (esA2=="1") { if(esEA=="1") { if(esEA=="1") { if(elemento=="0") { fich<<"Intensidad de "<<queescribo(p_DATOS->tableMDG->text(j,0))<< " entre nodos "<<nodoi<<", " <<nodoj<<": "<<texto<<endl; fichero.getline(texto,256); } if(elemento=="2") { fich<<"Intensidad de "<<queescribo(p_DATOS->tableMDG->text(j,0))<< " entre nodos "<<nodoi<<", " <<nodoj<<": "<<texto<<endl; fichero.getline(texto,256); } if(elemento=="8") {fich<<"I de Fuente de I dependiente de V entre nodos "<<nodom<<", "<< nodon<<": "<<texto<<endl; fichero.getline(texto,256);} } } } } fichero.close(); } if(p_DATOS->transitorio==1) { PetscViewerASCIIOpen(PETSC_COMM_WORLD, "variables.data", &viewer); PetscViewerDestroy(viewer);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.6

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401

Resultados

fstream fich("variables.data", ios::in |ios::out | ios::trunc | ios::binary); char texto[100]; ifstream fichero; // Abro para lectura fichero.open("x_trans.data"); if (!fichero) { cout << "No se ha podido abrir el fichero variables data."<< endl; exit(1); } fichero.getline(texto,256); //fichero >> texto; for (int i=0; i<p_DATOS->nodos; i++) { fich<<"V en nodo "<<i+1<<"\n"; fichero.getline(texto,256); } QString esA2, esEA, elemento, nodoi, nodoj, nodom, nodon; for(int j=0; j<p_DATOS->elementos;j++) { esA2=p_DATOS->tableMDG->text(j,3); esEA=p_DATOS->tableMDG->text(j,2); elemento=p_DATOS->tableMDG->text(j,0); nodoi=p_DATOS->tableMN->text(j,0); nodoj=p_DATOS->tableMN->text(j,1); nodom=p_DATOS->tableMN->text(j,2); nodon=p_DATOS->tableMN->text(j,3); if (esA2=="2") { if(elemento=="1") {fich<<"I Resistencia entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256);} if(elemento=="3") {fich<<"I de Bobina entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256);} if(elemento=="4") {fich<<"I de Fuente tension entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256);} if(elemento=="6") {fich<<"I de Amplificador entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256);} if(elemento=="7") {fich<<"I de Trafo entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256); fich<<"I de Trafo entre nodos "<<nodom<<", "<<nodon<<endl; fichero.getline(texto,256);} if(elemento=="9") {fich<<"I de Fuente de V dependiente de V entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256);} if(elemento=="10") {fich<<"I de Fuente de I dependiente de I entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256);} if(elemento=="11") {fich<<"I de Fuente de V dependiente de I entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256); fich<<"I de Fuente de V dependiente de I entre nodos "<<nodom<<", "<<nodon<<endl; fichero.getline(texto,256);} if(elemento=="12") {fich<<"I de Bobinas Acopladas entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256); fich<<"I de Bobinas Acopladas entre nodos "<<nodom<<", "<<nodon<<endl; fichero.getline(texto,256);} if(elemento=="13") {fich<<"I que recorre el Interruptor entre nodos "<<nodoi<<", "<<nodoj<<"\n"; fichero.getline(texto,256);}

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.6

402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443

Resultados

if(elemento=="15") {fich<<"I de Cuatripolo en Z entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256); fich<<"I de Cuatripolo en Z entre nodos "<<nodom<<", "<<nodon<<endl; fichero.getline(texto,256);} if(elemento=="16") {fich<<"I de Cuatripolo en h entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256);} if(elemento=="17") {fich<<"I de Cuatripolo en r entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256);} } if (esA2=="1") { if(esEA=="1") { if(esEA=="1") { if(elemento=="0") { fich<<"Intensidad de "<<queescribo(p_DATOS->tableMDG->text(j,0))<< " entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256); } if(elemento=="2") { fich<<"Intensidad de "<<queescribo(p_DATOS->tableMDG->text(j,0))<< " entre nodos "<<nodoi<<", "<<nodoj<<endl; fichero.getline(texto,256); } if(elemento=="8") {fich<<"I de Fuente de I dependiente de V entre nodos "<<nodom<< ", "<<nodon<<endl;fichero.getline(texto,256);} } } } } fichero.close(); } return 0; }

5.6.2.4.

QString queescribo (QString escribir)

Función que se encarga de complementar a mostrar_solucion para escribir el tipo de elemento del que se está tomando la variable Esta función, dependiendo de que elemento, retorna un QString con el nombre del mismo para poder escribirlo en el fichero de soluciones. Parámetros: Puntero a estructura basicos Ver también: mostrar_solucion Devuelve: Retorna un QString con el nombre del elemento al cual pertenece la variable que se ha calculado Definición en la línea 448 del archivo estructuras.cpp.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.7

Selección de filas en las Qtable

449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484

{ QString retorno; bool result; int escrito; escrito=escribir.toInt(&result,10); switch (escrito) { case 0: retorno="Conductancia"; return retorno;break; case 1: cout<<"\n ERROR La resistencia es siempre del Grupo A2"<< endl ;break; case 2: retorno="Condensador"; return retorno;break; case 3: cout<<"\n ERROR La bobina es siempre del Grupo A2"<< endl;break; case 4: retorno="Fuente de Tensión"; return retorno;break; case 5: retorno="Fuente de Corriente"; return retorno;break; case 6: retorno="Amplificador Operacional"; return retorno;break; case 7: retorno="Transformador"; return retorno;break; case 8: retorno="Fuente de Corriente dependiente de Tensión"; return retorno;break; case 9: retorno="Fuente de Tensión dependiente de Tensión"; return retorno;break; case 10: retorno="Fuente de Intensidad dependiente de Intensidad"; return retorno;break; case 11: retorno="Fuente de Tensión dependiente de Intensidad"; return retorno;break; case 12: retorno="Bobinas Acopladas"; return retorno;break; case 13: cout<<"\n ERROR Este elemento no existe en Ávalon"<< endl; break; } }

5.6.2.5.

QString script (basicos ∗ p_DATOS)

Función que se abrir el script para que el usuario pueda modificarlo y adaptarlo a sus necesidades. Parámetros: Puntero a estructura basicos Por defecto esta función abre el fichero con el editor de texto kwrite, si se quisiese que lo abriese con otro editor debería realizarse la modificación oportuna en el código. Definición en la línea 724 del archivo estructuras.cpp. 725 726 727 728 729

5.7.

{ QString comando = p_DATOS->datos_script; comando.prepend("kwrite ");//añade "convert " al string comando return comando; }

Selección de filas en las Qtable

Selecciona varias filas de distintas tablas. Selección filas se encarga de selecionar las filas simultáneamente de las diferentes Qtable de la pestaña ∗.spc, es decir MDG, MN y MVC. Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.7

Selección de filas en las Qtable

Slots públicos virtual void sbcl_principal::slt_seleccionfilasMDG () Este Slot se encarga de detectar en que fila de la Qtable Matriz de Datos Generales se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla.

virtual void sbcl_principal::slt_seleccionfilasMN () Este Slot se encarga de detectar en que fila de la Qtable Matriz de Nodos se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla.

virtual void sbcl_principal::slt_seleccionfilasMVC () Este Slot se encarga de detectar en que fila de la Qtable Matriz de Valores Característicos se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla.

5.7.1.

Descripción detallada

Slots públicos void sbcl_principal::slt_seleccionfilasMDG () [virtual, slot, inherited]

Este Slot se encarga de detectar en que fila de la Qtable Matriz de Datos Generales se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla. Definición en la línea 382 del archivo sbcl_principal.cpp. 383 384 385 386 387 388 389 390 391

{ int fila=tableMDG->currentRow(); int num_columnas=tableMDG->numRows(); for(int i=0;i<num_columnas;i++) {tableMDG->removeSelection(i);tableMN->removeSelection(i);tableMVC->removeSelection(i);} tableMDG->selectRow(fila); tableMN->selectRow(fila); tableMVC->selectRow(fila); }

5.7.2.2.

void sbcl_principal::slt_seleccionfilasMN () [virtual, slot, inherited]

Este Slot se encarga de detectar en que fila de la Qtable Matriz de Nodos se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla. Definición en la línea 393 del archivo sbcl_principal.cpp. 394 395 396 397 398

{ int fila=tableMN->currentRow(); int num_columnas=tableMN->numRows(); for(int i=0;i<num_columnas;i++) {tableMDG->removeSelection(i);tableMN->removeSelection(i);tableMVC->removeSelection(i);}

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.8

399 400 401 402

Creación del sistema general de ecuaciones lineales

tableMDG->selectRow(fila); tableMN->selectRow(fila); tableMVC->selectRow(fila); }

5.7.2.3.

void sbcl_principal::slt_seleccionfilasMVC () [virtual, slot, inherited]

Este Slot se encarga de detectar en que fila de la Qtable Matriz de Valores Característicos se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla. Definición en la línea 404 del archivo sbcl_principal.cpp. 405 406 407 408 409 410 411 412 413 414 415 416

5.8.

{ basicos *p_DATOS=&DATOS; int fila=tableMVC->currentRow(); int *elemento=&fila; int num_columnas=tableMVC->numRows(); for(int i=0;i<num_columnas;i++) {tableMDG->removeSelection(i);tableMN->removeSelection(i);tableMVC->removeSelection(i);} tableMDG->selectRow(fila); tableMN->selectRow(fila); tableMVC->selectRow(fila); }

Creación del sistema general de ecuaciones lineales

Diagrama de colaboración para Creación del sistema general de ecuaciones lineales: Generación de las variables del sistema matricial Tx=W

Creación del sistema general de ecuaciones lineales

Ensamblaje los elementos en el sistema lineal

Forma de cargar los distintos elementos que componen un circuito

Módulos Generación de las variables del sistema matricial Tx=W Conjunto de funciones que se encarga de preparar los elementos del sistema matricial Tx=W .

Forma de cargar los distintos elementos que componen un circuito Este conjunto de funciones se encarga de indicar los límites del vector del elemento que se carga en las Qtable: MDG, MN y MVC. El grupo de funciones lee_elementoX envía los límites del vector que los define para un correcto tratamiento de los datos de los elementos de un circuito. De esta forma se pueden generar nuevos elementos de manera más sencilla y sin limitaciones en los parámetros de definición. Para más información leer manual de funcionamiento de Ávalon.

Ensamblaje los elementos en el sistema lineal

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.9

Ensamblaje los elementos en el sistema lineal

5.8.1.

Descripción detallada

Este grupo de funciones recoge los pasos necesarios para el dimensionamiento, lectura y ensamblaje de datos para la creación del sistema de ecuaciones al que se reduce todo análisis de circuitos en este programa. Este grupo se divide en otros tres más, a saber: Generación de las variables del sistema matricial Tx=W Forma de cargar los diferentes elementos que componen un circuito Ensamblaje los elementos en el sistema lineal

5.9.

Ensamblaje los elementos en el sistema lineal

Diagrama de colaboración para Ensamblaje los elementos en el sistema lineal: Ensamblaje sobre la Matriz T Creación del sistema general de ecuaciones lineales

Ensamblaje los elementos en el sistema lineal Ensamblaje sobre el Vector W

Módulos Ensamblaje sobre la Matriz T Ensamblaje sobre el Vector W Funciones void elementoMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga de seleccionar a que función debe llamarse según el elemento que se este leyendo en tablas.

void elementoVectorW (double ∗p_elemento, basicos ∗p_DATOS, float t) Esta Función se encarga de seleccionar a que función debe llamarse según el elemento que se este leyendo en tablas.

5.9.1.

Descripción detallada

Este grupo de funciones es la encargada de realizar el ensamblaje del sistema lineal de ecuaciones que debe resolver el programa. Se dividen las funciones a su vez en dos grupos más en función de su contribución, a saber: Contribución a la Matriz T Contribución al Vector W

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.9

Ensamblaje los elementos en el sistema lineal

5.9.2. 5.9.2.1.

Documentación de las funciones void elementoMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga de seleccionar a que función debe llamarse según el elemento que se este leyendo en tablas. Para esto hace uso del switch Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 10 del archivo elementos.cpp. 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

{ double tipo_elemento0= *p_elemento; int tipo_elemento=int(tipo_elemento0); switch (tipo_elemento) { case 0: conductanciaMatrizT(p_elemento,p_DATOS);break; case 1: resistenciaMatrizT(p_elemento,p_DATOS);break; case 2: condensadorMatrizT(p_elemento,p_DATOS);break; case 3: bobinaMatrizT(p_elemento,p_DATOS);break; case 4: fuenteVccMatrizT(p_elemento,p_DATOS);break; case 5: break; case 6: amplificadorMatrizT(p_elemento,p_DATOS);break; case 7: trafoMatrizT(p_elemento,p_DATOS);break; case 8: fuenteIdependVMatrizT(p_elemento,p_DATOS);break; case 9: fuenteVdependVMatrizT(p_elemento,p_DATOS);break; case 10: fuenteIdependIMatrizT(p_elemento,p_DATOS);break; case 11: fuenteVdependIMatrizT(p_elemento,p_DATOS);break; case 12: bobinaacopladaMatrizT(p_elemento,p_DATOS);break; case 13: interruptorMatrizT(p_elemento,p_DATOS);break; case 14: cuadripoloAdmitanciaMatrizT(p_elemento,p_DATOS);break; case 15: cuadripoloImpedanciaMatrizT(p_elemento,p_DATOS);break; case 16: cuadripoloHibridoMatrizT(p_elemento,p_DATOS);break; case 17: cuadripoloTrasmisionMatrizT(p_elemento,p_DATOS);break; case 18: {cout<<"\n ERROR Asegúrese de que la librería está adaptada a Ávalon"<< endl; break;} } }

5.9.2.2.

void elementoVectorW (double ∗ p_elemento, basicos ∗ p_DATOS, float t)

Esta Función se encarga de seleccionar a que función debe llamarse según el elemento que se este leyendo en tablas. Para esto hace uso del switch Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos t Valor de tiempo, importante en las funciones de fuentes de excitación para calcular el valor temporal de dicha excitación Definición en la línea 1964 del archivo elementos.cpp.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993

Ensamblaje sobre la Matriz T

{ double tipo_elemento0= *p_elemento; int tipo_elemento=int(tipo_elemento0); /*for(int i=0;i<16;i++){cout<<p_elemento[i]<<" ";} cout<<endl;*/ switch (tipo_elemento) { case 0: break; case 1: p_DATOS->apuntaA2=p_DATOS->apuntaA2+1;break; case 2: if(p_elemento[2]==1){p_DATOS->apuntaEA=p_DATOS->apuntaEA+1;}break; case 3: p_DATOS->apuntaA2=p_DATOS->apuntaA2+1;break; case 4: fuenteVccVectorW(p_elemento,p_DATOS,t);break; case 5: fuenteIVectorW(p_elemento,p_DATOS,t);break; case 6: p_DATOS->apuntaA2=p_DATOS->apuntaA2+1;break; case 7: p_DATOS->apuntaA2=p_DATOS->apuntaA2+2;break; case 8: if(p_elemento[2]==1){p_DATOS->apuntaEA=p_DATOS->apuntaEA+1;}break; case 9: p_DATOS->apuntaA2=p_DATOS->apuntaA2+1;break; case 10: p_DATOS->apuntaA2=p_DATOS->apuntaA2+1;break; case 11: p_DATOS->apuntaA2=p_DATOS->apuntaA2+2;break; case 12: p_DATOS->apuntaA2=p_DATOS->apuntaA2+2;break; case 13: p_DATOS->apuntaA2=p_DATOS->apuntaA2+1;break; case 14: break; case 15: p_DATOS->apuntaA2=p_DATOS->apuntaA2+2;break; case 16: p_DATOS->apuntaA2=p_DATOS->apuntaA2+1;break; case 17: p_DATOS->apuntaA2=p_DATOS->apuntaA2+1;break; case 18: {cout<<"\n ERROR Asegúrese de que la librería está adaptada a Ávalon"<< endl; break;} } //cout<<"\n Primer valor del vector de datos elementos "<<p_elemento[1]<<endl; }

5.10.

Ensamblaje sobre la Matriz T

Diagrama de colaboración para Ensamblaje sobre la Matriz T: Ensamblaje los elementos en el sistema lineal

Ensamblaje sobre la Matriz T

Funciones void conductanciaMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la conductancia.

void resistenciaMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la resistencia.

void condensadorMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la condensador.

void bobinaMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la bobina.

void fuenteVccMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente independiente de tensión.

void amplificadorMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T del amplificador operacional ideal.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

void trafoMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T del transformador ideal.

void fuenteIdependVMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente de corriente dependiente de tensión.

void fuenteVdependVMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente de tensión dependiente de tensión.

void fuenteIdependIMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente de corriente dependiente de corriente.

void fuenteVdependIMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente de tensión dependiente de corriente.

void bobinaacopladaMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de bobinas acopladas.

void interruptorMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T del interruptor.

void cuadripoloAdmitanciaMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de un cuadripolo definido por sus parámetros de admitancia.

void cuadripoloImpedanciaMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de un cuadripolo definido por sus parámetros de impedancia.

void cuadripoloHibridoMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de un cuadripolo definido por sus parámetros híbridos.

void cuadripoloTrasmisionMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de un cuadripolo definido por sus parámetros de trasmisión.

5.10.1.

Descripción detallada

Este grupo de funciones es el encargado de realizar el ensamblaje en la Matriz T.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

5.10.2. 5.10.2.1.

Documentación de las funciones void amplificadorMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T del amplificador operacional ideal. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 227 del archivo elementos.cpp. 228 { 229 PetscScalar Valor=p_elemento[9]; 230 //un nodo conectado al de referencia 231 if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0) 232 { 233 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); 234 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,Valor,ADD_VALUES); 235 MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); 236 } 237 238 if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0) 239 { 240 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); 241 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,Valor,ADD_VALUES); 242 MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); 243 } 244 245 if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0) 246 { 247 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); 248 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); 249 } 250 251 //Dos nodos conectados al de referencia 252 if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0) 253 { 254 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); 255 } 256 257 if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0) 258 { 259 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); 260 } 261 262 if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0) 263 { 264 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,Valor,ADD_VALUES); 265 MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); 266 } 267 268 if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0) 269 { 270 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); 271 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); 272 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,Valor,ADD_VALUES); 273 MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); 274 } 275 }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

5.10.2.2.

void bobinaacopladaMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de bobinas acopladas. Este elemento pertenece al grupo A2 por lo que siempre aporta dos ecuaciones adicionales Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 1028 del archivo elementos.cpp. 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081

{ PetscScalar ValorL1, ValorL2, ValorM; PetscImaginaryPart(ValorL1)=p_elemento[14]; PetscImaginaryPart(ValorL2)=p_elemento[15]; //PetscImaginaryPart(ValorM)=p_elemento[16]*sqrt(p_elemento[14]*p_elemento[15]); PetscImaginaryPart(ValorM)=p_elemento[16]; if(p_elemento[2]==1)//Ver si no es EA { cout<<"\nError de concepto en inductor "<<p_elemento[0]<<" con ID relativo: "<< p_elemento[1]<<", este no puede ser EA, ya que su ensamblaje siempre es como si lo fuese"<<endl; } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[5]==0 && p_elemento[4]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[6]==0 && p_elemento[5]!=0 && p_elemento[4]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148

Ensamblaje sobre la Matriz T

MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[7]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[4]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } //dos nodos conectados al nodo de referencia if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215

Ensamblaje sobre la Matriz T

MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } //tres nodos conectados al de referencia if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 }

5.10.2.3.

//segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-ValorL1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-ValorM,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-ValorL2,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); }

void bobinaMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la bobina. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 164 del archivo elementos.cpp. 165 166 167 168 169 170 171 172 173 174 175 176

{ PetscScalar Valor; PetscImaginaryPart(Valor)=p_elemento[7]; if(p_elemento[2]==1)//Ver si no es EA { cout<<"\nError de concepto en inductor "<<p_elemento[0]<<" con ID relativo: "<< p_elemento[1]<<", este no puede ser EA, pertenece al grupo A2 por lo que es equivalente"<<endl; } //PetscScalar Valor[0]; //PetscImaginaryPart(Valor[0])=p_elemento[7]; //cout<<"inductor: "<<Valor[0]<<endl;

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 }

5.10.2.4.

if(p_elemento[4]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[5]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]!=0&&p_elemento[5]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); }

void condensadorMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la condensador. Este elemento pertenece al grupo A1 por lo que puede aportar una ecuación adicional si se desea obtener la intensidad que pasa por el Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 116 del archivo elementos.cpp. 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143

{ PetscScalar Valor; PetscImaginaryPart(Valor)=p_elemento[7]; cout<<"valor: "<<Valor<<endl; if(p_elemento[2]==0)//Ver si no es EA { if(p_elemento[4]==0) { MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,Valor,ADD_VALUES); } if(p_elemento[5]==0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,Valor,ADD_VALUES); } if(p_elemento[4]!=0&&p_elemento[5]!=0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[4]-1,-Valor,ADD_VALUES); } } else//Es EA { if(p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_elemento[5]-1,-Valor,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 } 162 }

5.10.2.5.

MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_DATOS->apuntaEA,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaEA,-1,ADD_VALUES); } if(p_elemento[5]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_DATOS->apuntaEA,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaEA,1,ADD_VALUES); } if(p_elemento[4]!=0&&p_elemento[5]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_DATOS->apuntaEA,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaEA,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaEA,-1,ADD_VALUES); }

void conductanciaMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la conductancia. Este elemento pertenece al grupo A1 por lo que puede aportar una ecuación adicional si se desea obtener la intensidad que pasa por el Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 39 del archivo elementos.cpp. 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

{ if(p_elemento[2]==0)//Ver si no es EA { cout<<"valores de la conductancia: "<<p_elemento[4]-1<<" "<<p_elemento[5]-1<< " "<<p_elemento[7]<<endl; if(p_elemento[4]==0) {MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,p_elemento[7],ADD_VALUES);} if(p_elemento[5]==0) {MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,p_elemento[7],ADD_VALUES);} if(p_elemento[4]!=0&&p_elemento[5]!=0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,p_elemento[7],ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,p_elemento[7],ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[5]-1,-p_elemento[7],ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[4]-1,-p_elemento[7],ADD_VALUES); } } else//Es EA { if(p_elemento[4]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_elemento[5]-1,-p_elemento[7],ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_DATOS->apuntaEA,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaEA,-1,ADD_VALUES); } if(p_elemento[5]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_elemento[4]-1,p_elemento[7],ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_DATOS->apuntaEA,-1,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

69 70 71 72 73 74 75 76 77 78 79 80 81 82

Ensamblaje sobre la Matriz T

MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaEA,1,ADD_VALUES); } if(p_elemento[5]!=0&&p_elemento[4]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_elemento[4]-1,p_elemento[7],ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_elemento[5]-1,-p_elemento[7],ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaEA,p_DATOS->apuntaEA,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaEA,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaEA,-1,ADD_VALUES); } //Incremento en uno el valor para poder poner otra EA si la hubiese p_DATOS->apuntaEA=p_DATOS->apuntaEA+1; } }

5.10.2.6.

void cuadripoloAdmitanciaMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de un cuadripolo definido por sus parámetros de admitancia. Este elemento pertenece al grupo A1 y no tiene posibilidad de aportar ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 1284 del archivo elementos.cpp. 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318

{ PetscScalar y11=p_elemento[14]; PetscScalar y12=p_elemento[15]; PetscScalar y21=p_elemento[16]; PetscScalar y22=p_elemento[17]; if(p_elemento[2]==1)//Ver si no es EA { cout<<"\nError de concepto en este tipo de cuatripolo "<<p_elemento[0]<< " con ID relativo: "<<p_elemento[1]<< ", este no puede ser EA, cuando se define según parámetros de admitancia"<<endl; } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[7]-1,-y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[7]-1,-y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[6]-1,-y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,y22,ADD_VALUES); } if(p_elemento[5]==0 && p_elemento[4]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[6]-1,y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[7]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[7]-1,-y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[6]-1,-y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,y22,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385

Ensamblaje sobre la Matriz T

} if(p_elemento[6]==0 && p_elemento[5]!=0 && p_elemento[4]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[5]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[7]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[4]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[7]-1,-y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,y22,ADD_VALUES); } if(p_elemento[7]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[4]!=0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[5]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[6]-1,y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[4]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,y22,ADD_VALUES); } //dos nodos conectados al nodo de referencia if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[6]-1,y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,y22,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[7]-1,-y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,y22,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,y22,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[7]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,y22,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[7]-1,-y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[6]-1,-y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,y22,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0)

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 }

5.10.2.7.

{ MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[5]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[4]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,y11,ADD_VALUES); } //tres nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,y11,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,y11,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,y22,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,y22,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[4]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[5]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[6]-1,y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[7]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[4]-1,-y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[5]-1,y11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[7]-1,-y12,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[7]-1,-y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,y21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[6]-1,-y22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,y22,ADD_VALUES); }

void cuadripoloHibridoMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de un cuadripolo definido por sus parámetros híbridos. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 1627 del archivo elementos.cpp. 1628 {

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695

Ensamblaje sobre la Matriz T

PetscScalar h11=p_elemento[14]; PetscScalar h12=p_elemento[15]; PetscScalar h21=p_elemento[16]; PetscScalar h22=p_elemento[17]; if(p_elemento[2]==1)//Ver si no es EA { cout<<"\nError de concepto en este tipo de cuatripolo "<<p_elemento[0]<<" con ID relativo: "<<p_eleme } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[7]-1,-h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,h21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[6]-1,-h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-h21,ADD_VALUES); } if(p_elemento[5]==0 && p_elemento[4]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[7]-1,-h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,h21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[6]-1,-h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-h21,ADD_VALUES); } if(p_elemento[6]==0 && p_elemento[5]!=0 && p_elemento[4]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-h21,ADD_VALUES); } if(p_elemento[7]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[4]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,h21,ADD_VALUES); } //dos nodos conectados al nodo de referencia if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,h21,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762

Ensamblaje sobre la Matriz T

} if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-h21,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,h21,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-h21,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[7]-1,-h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,h21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[6]-1,-h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-h21,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } //tres nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 }

5.10.2.8.

if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,h21,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-h21,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,h12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-h11,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[6]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[7]-1,-h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,h21,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[6]-1,-h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[7]-1,h22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-h21,ADD_VALUES); }

void cuadripoloImpedanciaMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de un cuadripolo definido por sus parámetros de impedancia. Este elemento pertenece al grupo A2 por lo que siempre aporta dos ecuaciones adicionales Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 1433 del archivo elementos.cpp. 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447

{ PetscScalar z11=p_elemento[14]; PetscScalar z12=p_elemento[15]; PetscScalar z21=p_elemento[16]; PetscScalar z22=p_elemento[17]; if(p_elemento[2]==1)//Ver si no es EA { cout<<"\nError de concepto en este tipo de cuatripolo "<<p_elemento[0]<< " con ID relativo: "<<p_elemento[1]<< ", este no puede ser EA, cuando se define según parámetros de admitancia"<<endl; } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514

Ensamblaje sobre la Matriz T

MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[5]==0 && p_elemento[4]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[6]==0 && p_elemento[5]!=0 && p_elemento[4]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[7]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[4]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } //dos nodos conectados al nodo de referencia if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581

Ensamblaje sobre la Matriz T

MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } //tres nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0)

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 }

5.10.2.9.

{ MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-z11,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2+1,-z12,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-z21,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-z22,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); }

void cuadripoloTrasmisionMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de un cuadripolo definido por sus parámetros de trasmisión. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 1797 del archivo elementos.cpp. 1798 { 1799 PetscScalar A=p_elemento[14]; 1800 PetscScalar B=p_elemento[15];

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867

Ensamblaje sobre la Matriz T

PetscScalar C=p_elemento[16]; PetscScalar D=p_elemento[17]; if(p_elemento[2]==1)//Ver si no es EA { cout<<"\nError de concepto en este tipo de cuatripolo "<<p_elemento[0]<< " con ID relativo: "<<p_elemento[1]<< ", este no puede ser EA, cuando se define según parámetros de admitancia"<<endl; } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[7]-1,C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[5]==0 && p_elemento[4]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[6]-1,C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[7]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,-D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[6]==0 && p_elemento[5]!=0 && p_elemento[4]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[7]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,-D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[7]-1,C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[7]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[4]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[6]-1,C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,-D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } //dos nodos conectados al nodo de referencia if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[6]-1,C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,-D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934

Ensamblaje sobre la Matriz T

if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[7]-1,C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[7]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,-D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,-D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,D,ADD_VALUES); } //tres nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,D,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,-D,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 }

5.10.2.10.

MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,A,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,B,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[6]-1,C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_elemento[7]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,-D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[6]-1,-C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_elemento[7]-1,C,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,D,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); }

void fuenteIdependIMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente de corriente dependiente de corriente. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 731 del archivo elementos.cpp. 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752

{ PetscScalar Valor=p_elemento[9]; if(p_elemento[2]==1)//Ver si es EA { cout<<"Este elemento pertenece al grupo A2"<<endl; } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-Valor,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819

Ensamblaje sobre la Matriz T

} if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,Valor,ADD_VALUES); } //Dos nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 }

5.10.2.11.

if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,Valor,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); }

void fuenteIdependVMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente de corriente dependiente de tensión. Este elemento pertenece al grupo A1 por lo que puede aportar una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 456 del archivo elementos.cpp. 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476

{ PetscScalar Valor=p_elemento[9]; if(p_elemento[2]==1)//Ver si es EA { //un nodo conectado al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543

Ensamblaje sobre la Matriz T

if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } //Dos nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610

Ensamblaje sobre la Matriz T

} } if(p_elemento[2]==0)//No es EA { //un terminal conectado al nodo de referencia if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-Valor,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,Valor,ADD_VALUES); } //dos nodos conectados al nudo de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,Valor,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,Valor,ADD_VALUES); } //Ningún nodo es el de referencia if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_elemento[5]-1,Valor,ADD_VALUES); } }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

611 }

5.10.2.12.

void fuenteVccMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente independiente de tensión. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional, puede definirse el tipo de excitación según lo indicado en la memoria principal de este proyecto Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 199 del archivo elementos.cpp. 200 { 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 }

5.10.2.13.

if(p_elemento[2]!=0)//Ver si no es EA { cout<<"Error de concepto en fuente de tensión "<<p_elemento[0]<< " con ID relativo: "<<p_elemento[1]<< ", este siempre es A2."<<endl; } if(p_elemento[4]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[5]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]!=0&&p_elemento[5]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); }

void fuenteVdependIMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente de tensión dependiente de corriente. Este elemento pertenece al grupo A2 por lo que siempre aporta dos ecuaciones adicionales Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 849 del archivo elementos.cpp. 850 {

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917

Ensamblaje sobre la Matriz T

PetscScalar Valor=p_elemento[9]; if(p_elemento[2]==1)//Ver si no es EA { cout<<"\nError de concepto en inductor "<<p_elemento[0]<< " con ID relativo: "<<p_elemento[1]<< ", este no puede ser EA, ya que su ensamblaje siempre es como si lo fuese"<<endl; } //un nodo conectado al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[6]==0 && p_elemento[5]!=0 && p_elemento[4]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[7]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[4]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } //dos nodos conectados al nodo de referencia if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984

Ensamblaje sobre la Matriz T

MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); } //tres nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 }

5.10.2.14.

if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { //primera EA //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { //primera EA //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); }

void fuenteVdependVMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la fuente de tensión dependiente de tensión. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 613 del archivo elementos.cpp. 614 615 616 617 618 619

{ PetscScalar Valor=p_elemento[9]; if(p_elemento[2]==1)//Ver si es EA { cout<<"Este elemento pertenece al grupo A2"<<endl; }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686

Ensamblaje sobre la Matriz T

//1 nodo conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } //Dos nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) {

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 }

5.10.2.15.

MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,Valor,ADD_VALUES); } //3 nodos al de referencia if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,-Valor,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); }

void interruptorMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T del interruptor. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 1254 del archivo elementos.cpp. 1255 1256 1257 1258 1259 1260

{ PetscScalar Valor=p_elemento[7]; PetscScalar Valor1=p_elemento[7]-1; if(p_elemento[2]==1)//Ver si es EA { cout<<"Este elemento pertenece al grupo A2"<<endl;

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

1261 } 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 }

5.10.2.16.

if(p_elemento[4]==0 && p_elemento[5]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,Valor1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); } if(p_elemento[5]==0 && p_elemento[4]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,Valor1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); } if(p_elemento[4]!=0&&p_elemento[5]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,Valor1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); }

void resistenciaMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T de la resistencia. Este elemento pertenece al grupo A2 por lo que puede siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 84 del archivo elementos.cpp. 85 { 86 if(p_elemento[2]==1)//Ver si no es EA 87 { 88 cout<<"Error de concepto en resistencia "<<p_elemento[0]<< 89 " con ID relativo: "<<p_elemento[1]<< 90 ", esta no puede ser EA, pertenece al grupo A2 por lo que es equivalente"<<endl; 91 } 92 93 if(p_elemento[4]==0 && p_elemento[5]!=0) 94 { 95 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); 96 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-p_elemento[7],ADD_VALUES); 97 MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); 98 } 99 if(p_elemento[5]==0 && p_elemento[4]!=0) 100 { 101 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); 102 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-p_elemento[7],ADD_VALUES); 103 MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); 104 } 105 if(p_elemento[4]!=0&&p_elemento[5]!=0) 106 { 107 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); 108 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); 109 MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_DATOS->apuntaA2,-p_elemento[7],ADD_VALUES); 110 MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); 111 MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES);

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

Ensamblaje sobre la Matriz T

112 113 114 }

5.10.2.17.

}

void trafoMatrizT (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en la matriz T del transformador ideal. Este elemento pertenece al grupo A2 por lo que siempre aporta dos ecuaciones adicionales Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos Definición en la línea 277 del archivo elementos.cpp. 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323

{ PetscScalar Valor=p_elemento[9]; PetscScalar Valorinver=1/p_elemento[9]; if(p_elemento[2]==1)//Ver si no es EA { cout<<"\nError de concepto en inductor "<<p_elemento[0]<< " con ID relativo: "<<p_elemento[1]<< ", este no puede ser EA, ya que su ensamblaje siempre es como si lo fuese"<<endl; } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[5]==0 && p_elemento[4]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[6]==0 && p_elemento[5]!=0 && p_elemento[4]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390

Ensamblaje sobre la Matriz T

if(p_elemento[7]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[4]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } //dos nodos conectados al nodo de referencia if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,Valor,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.10

391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 }

Ensamblaje sobre la Matriz T

if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); } //tres nodos conectados al de referencia if(p_elemento[4]==0 && p_elemento[5]!=0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]!=0 && p_elemento[7]==0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-Valor,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); } if(p_elemento[4]==0 && p_elemento[5]==0 && p_elemento[6]==0 && p_elemento[7]!=0) { MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,Valor,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); } if(p_elemento[4]!=0 && p_elemento[5]!=0 && p_elemento[6]!=0 && p_elemento[7]!=0) { //primera EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[4]-1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[5]-1,-1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[6]-1,-Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2,p_elemento[7]-1,Valor,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[4]-1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[5]-1,p_DATOS->apuntaA2,-1,ADD_VALUES); //segunda EA MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_DATOS->apuntaA2+1,p_DATOS->apuntaA2+1,-Valorinver,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[6]-1,p_DATOS->apuntaA2+1,1,ADD_VALUES); MatSetValue(p_DATOS->T,p_elemento[7]-1,p_DATOS->apuntaA2+1,-1,ADD_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.11

Ensamblaje sobre el Vector W

5.11.

Ensamblaje sobre el Vector W

Diagrama de colaboración para Ensamblaje sobre el Vector W: Ensamblaje los elementos en el sistema lineal

Ensamblaje sobre el Vector W

Funciones void bobinaVectorW (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en el vector W de una bobina.

void fuenteVccVectorW (double ∗p_elemento, basicos ∗p_DATOS, float t) Esta Función se encarga del ensamblaje de valores en el vector W de una fuente independiente de tensión.

void fuenteIVectorW (double ∗p_elemento, basicos ∗p_DATOS, float t) Esta Función se encarga del ensamblaje de valores en el vector W de una fuente independiente de corriente.

5.11.1.

Descripción detallada

Este grupo de funciones es el encargado de realizar el ensamblaje en el Vector W. 5.11.2. 5.11.2.1.

Documentación de las funciones void bobinaVectorW (double ∗ p_elemento, basicos ∗ p_DATOS)

Esta Función se encarga del ensamblaje de valores en el vector W de una bobina. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos

5.11.2.2.

void fuenteIVectorW (double ∗ p_elemento, basicos ∗ p_DATOS, float t)

Esta Función se encarga del ensamblaje de valores en el vector W de una fuente independiente de corriente. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos t Valor de tiempo, sirve para evaluar la excitación en el instante dado Definición en la línea 2077 del archivo elementos.cpp.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.11

2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144

Ensamblaje sobre el Vector W

{ float limite_a=p_elemento[10]; float limite_b=p_elemento[11]; double tipo_excitacion0= p_elemento[6]; int tipo_excitacion=int(tipo_excitacion0); float valor_n,valor_n1,valor; cout<<"valor de t: "<<t<<endl; if(p_elemento[2]==1)//Ver si es EA { cout<<"Error de concepto en fuente de intensidad "<<p_elemento[0]<< " con ID relativo: "<<p_elemento[1]<< ", pertenece al grupo A3 no puede ser ecuación adicional."<<endl; } switch (tipo_excitacion) { case 0:{if(p_DATOS->transitorio==1){valor_n=p_elemento[7];valor_n1=p_elemento[7];} if(p_DATOS->estacionario==1){valor=p_elemento[7];} break;} case 1:{if(p_DATOS->transitorio==1) {valor_n=p_elemento[12]*sin(p_elemento[9]*2*M_PI*(t*p_DATOS->h)+(p_elemento[8]*RAD)); cout<<"valor del seno de valor_n: "<<valor_n<<endl; valor_n1=p_elemento[12]*sin(p_elemento[9]*2*M_PI*(t*p_DATOS->h+p_DATOS->h)); cout<<"valor del argumento del seno: "<<t*p_DATOS->h+p_DATOS->h<<endl; cout<<"valor del elemento 8: "<<p_elemento[9]<<endl; cout<<"valor del seno de valor_n1: "<<valor_n1<<endl; } if(p_DATOS->estacionario==1){valor=p_elemento[12];} break;}//Seno case 2:{if(p_DATOS->transitorio==1) {valor_n=p_elemento[12]*cos(p_elemento[9]*2*M_PI*(t*p_DATOS->h)+(p_elemento[8]*RAD)); cout<<"valor del seno: "<<valor_n<<endl; valor_n1=p_elemento[12]*cos(p_elemento[9]*2*M_PI*(t*p_DATOS->h+p_DATOS->h)+ (p_elemento[8]*RAD));} if(p_DATOS->estacionario==1){valor=p_elemento[7];} break;}//Coseno case 3:{valor_n=p_elemento[12]*t+p_elemento[13]; valor_n1=p_elemento[12]*(t+p_DATOS->h)+p_elemento[13]; break;}//Rampa case 4:{ if(t<limite_a){valor_n=p_elemento[12];valor_n1=valor_n;} if(t>=limite_b){valor_n=p_elemento[13];valor_n1=valor_n;} break; }//Escalón case 5:{ if(t<limite_a){valor_n=p_elemento[14];valor_n1=valor_n;} if(t>=limite_b){valor_n=p_elemento[15];valor_n1=valor_n;} if((t>limite_a)&&(t<limite_b)) { valor_n=p_elemento[12]*t+p_elemento[13]; valor_n1=p_elemento[12]*(t+p_DATOS->h)+p_elemento[13]; } break; }//Escalón Modificado } cout<<"valor excitación: "<<valor_n<<endl; if(p_elemento[4]==0) { if(p_DATOS->transitorio==1){ VecSetValue(p_DATOS->Wn,p_elemento[5],valor_n,ADD_VALUES); VecSetValue(p_DATOS->Wn1,p_elemento[5],valor_n1,ADD_VALUES);} if(p_DATOS->estacionario==1){ VecSetValue(p_DATOS->W,p_elemento[5],valor,ADD_VALUES);} } if(p_elemento[5]==0)

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

5.11

Ensamblaje sobre el Vector W

2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 }

5.11.2.3.

{ if(p_DATOS->transitorio==1){ VecSetValue(p_DATOS->Wn,p_elemento[4],-valor_n,ADD_VALUES); VecSetValue(p_DATOS->Wn1,p_elemento[4],-valor_n1,ADD_VALUES);} if(p_DATOS->estacionario==1){ VecSetValue(p_DATOS->W,p_elemento[4],-valor,ADD_VALUES);} } if(p_elemento[4]!=0&&p_elemento[5]!=0) { if(p_DATOS->transitorio==1){ VecSetValue(p_DATOS->Wn,p_elemento[5],valor_n,ADD_VALUES); VecSetValue(p_DATOS->Wn1,p_elemento[5],valor_n1,ADD_VALUES); VecSetValue(p_DATOS->Wn,p_elemento[4],-valor_n,ADD_VALUES); VecSetValue(p_DATOS->Wn1,p_elemento[4],-valor_n1,ADD_VALUES);} if(p_DATOS->estacionario==1){ VecSetValue(p_DATOS->W,p_elemento[5],valor,ADD_VALUES); VecSetValue(p_DATOS->W,p_elemento[4],-valor,ADD_VALUES);} }

void fuenteVccVectorW (double ∗ p_elemento, basicos ∗ p_DATOS, float t)

Esta Función se encarga del ensamblaje de valores en el vector W de una fuente independiente de tensión. Este elemento pertenece al grupo A2 por lo que siempre aporta una ecuación adicional Parámetros: elemento Puntero a vector con los valores de definición del elemento p_DATOS Puntero a estructura basicos t Valor de tiempo, sirve para evaluar la excitación en el instante dado Definición en la línea 1995 del archivo elementos.cpp. 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6 Documentación de las clases

2025 (p_elemento[8]*RAD));} 2026 if(p_DATOS->estacionario==1){valor=p_elemento[7];} 2027 break;}//Coseno 2028 case 3:{ 2029 valor_n=p_elemento[12]*t+p_elemento[13]; 2030 valor_n1=p_elemento[12]*(t+p_DATOS->h)+p_elemento[13]; 2031 break;}//Rampa 2032 case 4:{ 2033 if(t<limite_a){valor_n=p_elemento[12];valor_n1=valor_n;} 2034 if(t>=limite_a){valor_n=p_elemento[13];valor_n1=valor_n;} 2035 break; 2036 }//Escalón 2037 case 5:{ 2038 if(t<=limite_a){valor_n=p_elemento[14];valor_n1=valor_n;} 2039 if(t>=limite_b){valor_n=p_elemento[15];valor_n1=valor_n;} 2040 if((t>limite_a)&&(t<limite_b)) 2041 { 2042 valor_n=p_elemento[12]*t+p_elemento[13]; 2043 valor_n1=p_elemento[12]*(t+p_DATOS->h)+p_elemento[13]; 2044 } 2045 break; 2046 }//Escalón Modificado 2047 } 2048 2049 if(p_elemento[4]==0) 2050 { 2051 if(p_DATOS->transitorio==1){ 2052 VecSetValue(p_DATOS->Wn,p_DATOS->apuntaA2,valor_n,ADD_VALUES); 2053 VecSetValue(p_DATOS->Wn1,p_DATOS->apuntaA2,valor_n1,ADD_VALUES);} 2054 if(p_DATOS->estacionario==1){ 2055 VecSetValue(p_DATOS->W,p_DATOS->apuntaA2,valor,ADD_VALUES);} 2056 } 2057 if(p_elemento[5]==0) 2058 { 2059 if(p_DATOS->transitorio==1){ 2060 VecSetValue(p_DATOS->Wn,p_DATOS->apuntaA2,valor_n,ADD_VALUES); 2061 VecSetValue(p_DATOS->Wn1,p_DATOS->apuntaA2,valor_n1,ADD_VALUES);} 2062 if(p_DATOS->estacionario==1){ 2063 VecSetValue(p_DATOS->W,p_DATOS->apuntaA2,valor,ADD_VALUES);} 2064 } 2065 if(p_elemento[4]!=0&&p_elemento[5]!=0) 2066 { 2067 if(p_DATOS->transitorio==1){ 2068 VecSetValue(p_DATOS->Wn,p_DATOS->apuntaA2,valor_n,ADD_VALUES); 2069 VecSetValue(p_DATOS->Wn1,p_DATOS->apuntaA2,valor_n1,ADD_VALUES);} 2070 if(p_DATOS->estacionario==1){ 2071 VecSetValue(p_DATOS->W,p_DATOS->apuntaA2,valor,ADD_VALUES);} 2072 } 2073 //Incremento en uno el valor para poder poner otro elemento EA si lo hubiese 2074 p_DATOS->apuntaA2=p_DATOS->apuntaA2+1; 2075 }

6. 6.1.

Documentación de las clases Referencia de la Estructura basicos

Estructura que almacena datos de interés para el correcto funcionamiento del programa. #include <estructuras.h>

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

Referencia de la Estructura basicos

Métodos públicos void almacena_long_max (int long_elemento) Almacena la longitud máxima de los elementos que componen el circuito.

int situaA2 () La función apunta a la fila donde se localiza el siguiente elemento del Grupo A2.

int situaEA () La función apunta a la fila donde se localiza la siguiente Ecuación Adicional.

int filas () Calcula el número de filas que debe tener la matriz T y el Vector W.

int columnas () Calcula el número de columnas que debe tener la matriz T.

Mat creaT () Se encarga de dimensionar la matriz T del sistema a resolver. NOTA: La matriz T es una matriz sparse generada con las funciones de la librería PETCs.

void creaGC () Se encarga de dimensionar las matrices del sistema transitorio G y C. NOTA: La matrices G y C son matrices sparse generadas con las funciones de la librería PETCs.

Vec creaW () Se encarga de dimensionar el vector W para el sistema estacionario NOTA: El vector W es un vector generado con las funciones de la librería PETCs.

Vec creaWn () Se encarga de dimensionar el vector Wn para el sistema transitorio NOTA: El vector Wn es un vector generado con las funciones de la librería PETCs.

Vec creaWn1 () Se encarga de dimensionar el vector Wn1 para el sistema transitorio NOTA: El vector Wn1 es un vector generado con las funciones de la librería PETCs.

Vec creax_perm () Se encarga de dimensionar el vector x para el sistema estacionario. En el se almacenan las soluciones del mismo. NOTA: El vector x_perm es un vector generado con las funciones de la librería PETCs.

Vec creax_trans () Se encarga de dimensionar el vector x para el sistema transitorio. En el se almacenan las soluciones del mismo. NOTA: El vector x_trans es un vector generado con las funciones de la librería PETCs.

Vec creax0 (int k, basicos ∗p_DATOS) Se encarga de dimensionar el vector x0 para el sistema transitorio. En el se almacenan las condiciones iniciales consistentes del mismo. NOTA: El vector x0 es un vector generado con las funciones de la librería PETCs.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

Referencia de la Estructura basicos

Atributos públicos QTable ∗ tableMN QTable ∗ tableMDG QTable ∗ tableMVC QTable ∗ tablex0 int long_max QString file_spc QString file_png QString file_sol_permanente QString datos_perm QString datos_trans QString datos_script QString solucion QString sol_trans QString sol_perm int elementos int EA int nodos int A2 int estacionario int transitorio int lim [3] float h float theta float t0 float tf float numv float t Mat T Mat G Mat C double nocero double densidad double dispersion Vec W Vec Wn Vec Wn1 Vec BBCC Vec x_perm Vec x_trans Vec xn Vec x0 int iter int estaT PetscScalar ∗ dimen PetscScalar ∗ X int apuntaEA int apuntaA2

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

Referencia de la Estructura basicos

6.1.1.

Descripción detallada

Estructura que almacena datos de interés para el correcto funcionamiento del programa. Esta estructura está pensada para almacenar todos los datos de interés para el estudio y uso del circuito que se esté analizando. Contiene variables que almacenan las direcciones de los ficheros que se generan, número de elementos del circuito, número de ecuaciones adicionales, número de elementos pertenecientes al grupo A2 y un largo etcétera. Definición en la línea 12 del archivo estructuras.h. 6.1.2. 6.1.2.1.

Documentación de las funciones miembro void basicos::almacena_long_max (int long_elemento) [inline]

Almacena la longitud máxima de los elementos que componen el circuito. Parámetros: long_elemento Longitud del elemento que se está leyendo Ver también: sbcl_principal::slt_abrirspc() La función compara el dato almacenado en long_max y si el valor del parámetro enviado es mayor lo almacena. Definición en la línea 65 del archivo estructuras.h. 65 {if(long_elemento>long_max)long_max=long_elemento;}

6.1.2.2.

int basicos::situaA2 () [inline]

La función apunta a la fila donde se localiza el siguiente elemento del Grupo A2. Definición en la línea 70 del archivo estructuras.h. 70 {int fila_situaA2=nodos; return fila_situaA2;};

6.1.2.3.

int basicos::situaEA () [inline]

La función apunta a la fila donde se localiza la siguiente Ecuación Adicional. Devuelve: Devuelve el valor de la fila para colocar el siguiente elemento que proporcione una ecuación adicional. Definición en la línea 75 del archivo estructuras.h. 75 {int fila_situaEA=nodos+A2; return fila_situaEA;}

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

Referencia de la Estructura basicos

6.1.2.4.

int basicos::filas () [inline]

Calcula el número de filas que debe tener la matriz T y el Vector W. Ver también: creaT() creaW() Definición en la línea 82 del archivo estructuras.h. 82 {int resultado_fila=nodos+A2+EA; return resultado_fila;}

6.1.2.5.

int basicos::columnas () [inline]

Calcula el número de columnas que debe tener la matriz T. Ver también: creaT() Definición en la línea 87 del archivo estructuras.h. 87 {int resultado_columna=nodos+A2+EA; return resultado_columna;}

6.1.2.6.

Vec basicos::creax0 (int k, basicos ∗ p_DATOS) [inline]

Se encarga de dimensionar el vector x0 para el sistema transitorio. En el se almacenan las condiciones iniciales consistentes del mismo. NOTA: El vector x0 es un vector generado con las funciones de la librería PETCs. Devuelve: Retorna un puntero a un vector PETCs Funcion que se encarga de dimensionar el vector de condiciones iniciales para el sistema transitorio e inicialiarlo con los valores introducidos por el usuario.(IMPORTANTE estos han de ser consistentes). Cuando nos encontramos en iteraciones diferentes a la inicial este vector almacena la solución del sistema anterior ya que así lo requiere la expresión del método iterativo utilizado. Definición en la línea 198 del archivo estructuras.h. 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214

{ VecCreate(PETSC_COMM_SELF,&x0); VecSetSizes(x0,PETSC_DECIDE,filas()); VecSetFromOptions(x0); if(k==1) { bool result; QString var_string; double var=0; int i=0; for( i=0;i<p_DATOS->filas();i++) { var_string=p_DATOS->tablex0->text(i,0); var= var_string.toDouble(&result); VecSetValue(x0,i,var,INSERT_VALUES); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

215 216 217 218 219 220 221 222 223

Referencia de la Estructura basicos

} else { VecCopy(p_DATOS->x_trans,x0); } VecAssemblyBegin(x0); VecAssemblyEnd(x0); return x0; }

6.1.3. 6.1.3.1.

Documentación de los datos miembro QTable∗ basicos::tableMN

Punteros a las QTable de la parte gráfica Definición en la línea 14 del archivo estructuras.h. 6.1.3.2.

QTable∗ basicos::tableMDG

Punteros a las QTable de la parte gráfica Definición en la línea 15 del archivo estructuras.h. 6.1.3.3.

QTable∗ basicos::tableMVC

Punteros a las QTable de la parte gráfica Definición en la línea 16 del archivo estructuras.h. 6.1.3.4.

QTable∗ basicos::tablex0

Punteros a las QTable de la parte gráfica Definición en la línea 17 del archivo estructuras.h. 6.1.3.5.

int basicos::long_max

Almacena longitud máxima Definición en la línea 18 del archivo estructuras.h. 6.1.3.6.

QString basicos::file_spc

Almacena la dirección del fichero ∗.spc Definición en la línea 19 del archivo estructuras.h. 6.1.3.7.

QString basicos::file_png

Almacena la dirección del fichero ∗.png Definición en la línea 20 del archivo estructuras.h. 6.1.3.8.

QString basicos::file_sol_permanente

Almacena la dirección del fichero en el que se almacena la solución del sistema permanente Definición en la línea 21 del archivo estructuras.h. Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

Referencia de la Estructura basicos

6.1.3.9.

QString basicos::datos_perm

Almacena la dirección del fichero en el que se almacena la matriz T y el vector W del sistema resuelto Definición en la línea 22 del archivo estructuras.h. 6.1.3.10.

QString basicos::datos_trans

Almacena la dirección del fichero en el que se almacena la matriz T y los vectores W del sistema resuelto Definición en la línea 23 del archivo estructuras.h. 6.1.3.11.

QString basicos::datos_script

Almacena la dirección del fichero en el que se almacena el script para representar el sistema resuelto con gnuplot Definición en la línea 24 del archivo estructuras.h. 6.1.3.12.

QString basicos::solucion

Almacena la dirección de la gráfica del sistema transitorio Definición en la línea 25 del archivo estructuras.h. 6.1.3.13.

QString basicos::sol_trans

Almacena la dirección del fichero en el que se almacena las soluciones del transitorio Definición en la línea 26 del archivo estructuras.h. 6.1.3.14.

QString basicos::sol_perm

Almacena la dirección del fichero en el que se almacena la solución del estacionario Definición en la línea 27 del archivo estructuras.h. 6.1.3.15.

int basicos::elementos

Valores básicos necesarios para diversos pasos en el proceso de calculo del sistema Definición en la línea 28 del archivo estructuras.h. 6.1.3.16.

int basicos::EA

Valores básicos necesarios para diversos pasos en el proceso de calculo del sistema Definición en la línea 29 del archivo estructuras.h. 6.1.3.17.

int basicos::nodos

Definición en la línea 30 del archivo estructuras.h. 6.1.3.18.

int basicos::A2

Valores básicos necesarios para diversos pasos en el proceso de calculo del sistema Definición en la línea 30 del archivo estructuras.h. Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

Referencia de la Estructura basicos

6.1.3.19.

int basicos::estacionario

Variables para saber que tipo de análisis se pretende realizar Definición en la línea 31 del archivo estructuras.h. 6.1.3.20.

int basicos::transitorio

Variables para saber que tipo de análisis se pretende realizar Definición en la línea 32 del archivo estructuras.h. 6.1.3.21.

int basicos::lim[3]

Vector que ayuda a la lectura de los elementos, almacena los límites de los valores para la introducción de los mismos en las QTable Definición en la línea 33 del archivo estructuras.h. 6.1.3.22.

float basicos::h

Variables necesarias para el transitorio h=paso de tiempo Definición en la línea 34 del archivo estructuras.h. 6.1.3.23.

float basicos::theta

Variables necesarias para el transitorio Definición en la línea 35 del archivo estructuras.h. 6.1.3.24.

float basicos::t0

Variables necesarias para el transitorio to=tiempo inicial Definición en la línea 36 del archivo estructuras.h. 6.1.3.25.

float basicos::tf

Variables necesarias para el transitorio tf=tiempo final Definición en la línea 37 del archivo estructuras.h. 6.1.3.26.

float basicos::numv

Variables necesarias para el transitorio numv=numero de iteraciones Definición en la línea 38 del archivo estructuras.h. 6.1.3.27.

float basicos::t

Variables necesarias para el transitorio Definición en la línea 39 del archivo estructuras.h.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

Referencia de la Estructura basicos

6.1.3.28.

Mat basicos::T

Es la matriz T del sistema Definición en la línea 40 del archivo estructuras.h. 6.1.3.29.

Mat basicos::G

Es la matriz G del sistema transitorio Definición en la línea 41 del archivo estructuras.h. 6.1.3.30.

Mat basicos::C

Es la matriz C del sistema transitorio Definición en la línea 42 del archivo estructuras.h. 6.1.3.31.

double basicos::nocero

Almacena el número de valores distintos a cero de la matriz T Definición en la línea 43 del archivo estructuras.h. 6.1.3.32.

double basicos::densidad

Almacena la densidad de la matriz T Definición en la línea 44 del archivo estructuras.h. 6.1.3.33.

double basicos::dispersion

Almacena la dispersión de la matriz T Definición en la línea 45 del archivo estructuras.h. 6.1.3.34.

Vec basicos::W

Vector W del sistema Definición en la línea 46 del archivo estructuras.h. 6.1.3.35.

Vec basicos::Wn

Vector Wn del sistema transitorio Definición en la línea 47 del archivo estructuras.h. 6.1.3.36.

Vec basicos::Wn1

Vector Wn1 del sistema trasitorio Definición en la línea 48 del archivo estructuras.h. 6.1.3.37.

Vec basicos::BBCC

Vector BBCC del sistema transitorio

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.1

Referencia de la Estructura basicos

Definición en la línea 49 del archivo estructuras.h. 6.1.3.38.

Vec basicos::x_perm

Vector solución del sistema esta el sistema estacionario Definición en la línea 50 del archivo estructuras.h. 6.1.3.39.

Vec basicos::x_trans

Definición en la línea 51 del archivo estructuras.h. 6.1.3.40.

Vec basicos::xn

Vector solución del sistema transitorio Definición en la línea 52 del archivo estructuras.h. 6.1.3.41.

Vec basicos::x0

Vector de condiciones iniciales del transitorio Definición en la línea 53 del archivo estructuras.h. 6.1.3.42.

int basicos::iter

Almacena la iteración que se está realizando Definición en la línea 54 del archivo estructuras.h. 6.1.3.43.

int basicos::estaT

Indica si la matriz T está ya ensamblada 1=si 0=no esto sirve para el transitorio, de esta forma no ensamblamos más de la cuenta Definición en la línea 55 del archivo estructuras.h. 6.1.3.44.

PetscScalar∗ basicos::dimen

Definición en la línea 56 del archivo estructuras.h. 6.1.3.45.

PetscScalar ∗ basicos::X

Definición en la línea 56 del archivo estructuras.h. 6.1.3.46.

int basicos::apuntaEA

Valor que almacena donde debo colocar la EA generada por un elemento del grupo A1 que me encuentre al ir montando Definición en la línea 57 del archivo estructuras.h.

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

6.1.3.47.

int basicos::apuntaA2

Valor que almacena donde debo colocar la EA generada por un elemento del grupo A2 que me encuentre al ir montando Definición en la línea 58 del archivo estructuras.h. La documentación para esta estructura fue generada a partir del siguiente fichero: Programacion/AVALON/src/estructuras.h

6.2.

Referencia de la Estructura sbcl_principal

Clase en la que se encuentran los diferentes slots utilizados para hacer funcionar la parte gráfica del programa. #include <sbcl_principal.h> Diagrama de colaboración para sbcl_principal: basicos

DATOS

sbcl_principal

Slots públicos virtual void slt_abrirspc () Este slot se encarga de abrir el fichero generado por el Xcircuit.

virtual void slt_abrirps () Slot encargado de abrir la imagen del circuito para visualizar el mismo en pestaña Circuito.

virtual void slt_xcircuit () Slot encargado de abrir el Xcircuit para realizar el diseño del circuito a través de la librería de elementos elaborada para Ávalon.

virtual void slt_resolver () El slot resolver se encarga comenzar los procesos necesarios para la resolución del sistema.

virtual void slt_analisis () Slot que se encarga de verificar que está seleccionado en tipo de análisis para así indicar a Ávalon como ha de comportarse en el análisis. Básicamente lo que hace es modificar los valores de unas variables en la clase basicos DATOS cuando el usuario cliquea en trasitorio o estacionario.

virtual void slt_seleccionfilasMDG () Este Slot se encarga de detectar en que fila de la Qtable Matriz de Datos Generales se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla.

virtual void slt_seleccionfilasMN () Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

virtual void slt_seleccionfilasMVC () Este Slot se encarga de detectar en que fila de la Qtable Matriz de Valores Característicos se realiza un click para selecionar la misma fila de las demás tablas, de esta forma el análisis de los elementos en mucho más sencilla.

virtual void slt_solEstacionario (basicos ∗p_DATOS) Este Slot se encarga de escribir en pantalla la solución del sistema estacionario.

virtual void slt_calculadora () Este Slot se encarga de lanzar una calculadora para posibles cálculos que el usuario pueda necesitar.

virtual void slt_prepara () Este slot se encarga preparar la tabla de condiciones iniciales Entre las tareas que realiza este slot se encuentra: .

virtual void slt_nuevoanalisis () Este slot se encarga purgar los valores necesarios para comenzar con un análisis de un nuevo circuito.

virtual void slt_gnuplot () Slot encargado de abrir el GNUPlot para realizar nuevos ploteos tras adaptar el script realizado por defecto.

virtual void slt_sobreQt () Slot encargado de lanzar el diálogo de información de la versión de Qt utilizada.

virtual void slt_ayuda () Slot encargado de abrir diálogo de información sobre el programa.

virtual void slt_sistemaestacionario () Slot que carga el sistema a resolver del estacionario en pantalla.

virtual void slt_sistematransitorio () Slot que carga los sistemas a resolver del transitorio en pantalla.

virtual void slt_solucionestacionario () Slot que carga la solución del estacionario en pantalla.

virtual void slt_soluciontransitorio () Slot que carga la solución del transitorio en pantalla.

virtual void slt_cargagrafico () Este slot abre el gráfico realizado con el script por defecto en pantalla.

virtual void slt_abrescript () Este slot abre el script que usa GNUPlot para generar el gráfico final de las variables calculadas.

virtual void slt_vermatrizT () Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

Este slot abre una visualización gráfica de la matriz sparse.

virtual void INFOgeneral (basicos ∗DATOS) Slot escargado de visualizar datos generales del circuito que se está analizando.

Métodos públicos sbcl_principal (QWidget ∗parent=0, const char ∗name=0, bool modal=FALSE, WFlags fl=0) Constructor de la clase principal.

∼sbcl_principal () Destructor de la clase principal.

Atributos públicos basicos DATOS Slots protegidos virtual void slt_resolucion (basicos ∗p_DATOS) Este Slot se encarga de seguir el proceso de resolución de los sistemas de ecuaciones del circuito a analizar.

6.2.1.

Descripción detallada

Clase en la que se encuentran los diferentes slots utilizados para hacer funcionar la parte gráfica del programa. En esta clase se encuentran las principales líneas que hacen funcionar al programa. Esta clase contiene los slots encargados de hacer que funciones los botones de la interfaz de usuario enlazando cuando es necesario con el resto de funciones existentes para que se ejecuten las operaciones que hacen posibles la obtención de las variables de los circuitos que se analizan. Definición en la línea 20 del archivo sbcl_principal.h. 6.2.2.

Documentación del constructor y destructor

6.2.2.1. sbcl_principal::sbcl_principal (QWidget ∗ parent = 0, const char ∗ name = 0, bool modal = FALSE, WFlags fl = 0) Constructor de la clase principal. Parámetros: parent Nos indica de que QWidget depende Definición en la línea 16 del archivo sbcl_principal.cpp. 17 18 { 19 }

: dlg_principal ( parent,name, modal,fl )//Constructor de la sbcl

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

6.2.2.2.

sbcl_principal::∼sbcl_principal ()

Destructor de la clase principal. Definición en la línea 21 del archivo sbcl_principal.cpp. 22 { 23 }

6.2.3.

Documentación de las funciones miembro

6.2.3.1.

void sbcl_principal::slt_abrirspc () [virtual, slot]

Este slot se encarga de abrir el fichero generado por el Xcircuit. Entre las tareas que realiza esta función se encuentra: Abrir el fichero ∗spc generado con Xcircuit Llamar a lee_elemento para asi clocar de forma correcta los valores en las tres Qtable existentes Generar el archivo ∗.png de dicho fichero para poder mostrar en pantalla el gráfico del circuito Ver también: lee_elemento Definición en la línea 26 del archivo sbcl_principal.cpp. 27 { 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

//Ventana diaologo para abrir el *.spc QString fichero_spc = QFileDialog::getOpenFileName("", "Circuito (*.spc)", this, "open file dialog", "Elige el Circuito a resolver" ); //Preparando direcciones de ficheros DATOS.file_spc=fichero_spc; QString fichero_ps = fichero_spc; fichero_ps.replace( ".spc", ".ps" ); QString fichero_png = fichero_spc; fichero_png.replace(".spc",".png"); DATOS.file_png=fichero_png; QString datos_xperm = fichero_spc; datos_xperm.replace(".spc","_x_perm.data"); DATOS.datos_perm=datos_xperm; QString datos_xtrans = fichero_spc; datos_xtrans.replace(".spc","_x_trans.data"); DATOS.datos_trans=datos_xtrans; QString datos_script = fichero_spc; datos_script.replace(".spc","_script.plot"); DATOS.datos_script=datos_script; QString grafica = fichero_spc; grafica.replace(".spc","_grafica.png"); DATOS.solucion=grafica; QString sol_trans = fichero_spc; sol_trans.replace(".spc","_sol_trans.data"); DATOS.sol_trans=sol_trans; QString sol_perm = fichero_spc; sol_perm.replace(".spc","_sol_perm.data"); DATOS.sol_perm=sol_perm; //transformando archivo gráfico a formato compatible con Qt QString comando = fichero_png; comando.prepend(" "); comando.prepend(fichero_ps); comando.prepend("convert ");//añade "convert " al string comando // ejecuta un comando de imagemagick para la conversion de imagen de ps a png system(comando); //Vista del Fichero por ventana

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

Referencia de la Estructura sbcl_principal

QFile *Document = new QFile(fichero_spc); if (!Document->open(IO_ReadOnly)) { cout << tr("File not found.") << endl; return; } //Determinando el número de elementos y escribiendo la matriz en la table de la GUI QStringList lines; QFile file( fichero_spc ); int num_line_total = 1;//es el numero de lineas del fichero QTextStream stream( &file ); QString line; int i=0, j=0; /*Esta lectura crea las filas necesarias para mostrar en la table los valores contenidos en el fichero *spc*/ if ( file.open( IO_ReadOnly ) ) { while ( !stream.atEnd() ) //lectura del fichero +.spc { line = stream.readLine(); // linea de texto excluyendo el ’\n’ num_line_total++; } lines += line; num_line_total=num_line_total-5; tableMDG->insertRows(0,num_line_total); //creación de las filas necesarias tableMN->insertRows(0,num_line_total); tableMVC->insertRows(0,num_line_total); //numero de elementos, se le resta 2 por la cabecera y tres por como termina el fichero DATOS.elementos=num_line_total; file.close(); }

if ( file.open( IO_ReadOnly ) ) { basicos *p_DATA=&DATOS;basicos *p_DATOS=&DATOS; int num_line=1; int esp_blnk; int cont=0; QString valor,identifelemen; p_DATOS->tableMDG=tableMDG;p_DATOS->tableMN=tableMN;p_DATOS->tableMVC=tableMVC; p_DATOS->tablex0=tablex0; while ( !stream.atEnd() ) { for (i=0;i<num_line_total;i++) { line = stream.readLine(); // linea de texto excluyendo el ’\n’ //Es el número de veces que debo leer la linea int num_lecturas_linea=line.contains(’ ’, FALSE); if (num_line>1 && line!=".end") { bool result; int elemento=0; esp_blnk = line.find( ’ ’ ); identifelemen = line.left( esp_blnk ); elemento= identifelemen.toInt(&result,10); lee_elemento (elemento,p_DATA); p_DATOS->almacena_long_max(p_DATA->lim[2]); for(j=0;j<p_DATA->lim[2];j++) { esp_blnk = line.find( ’ ’ ); if(cont<num_lecturas_linea) { valor = line.left( esp_blnk );

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 }

6.2.3.2.

//insertar valor en la tabla adecuada if (j<p_DATA->lim[0]){tableMDG->setText(i,j,valor);} if (j<p_DATA->lim[1] && j>=p_DATA->lim[0]) {tableMN->setText(i,(j-p_DATA->lim[0]), valor );} if (j<p_DATA->lim[2] && j>=p_DATA->lim[1]) {tableMVC->setText(i,(j-p_DATA->lim[1]), valor );} line.remove(0,esp_blnk+1); num_lecturas_linea=num_lecturas_linea+1; } } } num_line++; } } file.close(); }

void sbcl_principal::slt_abrirps () [virtual, slot]

Slot encargado de abrir la imagen del circuito para visualizar el mismo en pestaña Circuito. Definición en la línea 204 del archivo sbcl_principal.cpp. 205 206 207 208 209 210 211

{ basicos *p_DATOS=&DATOS; QPixmap *imagen; QString nombre_imagen=p_DATOS->file_png; imagen=new QPixmap(nombre_imagen); pixmapLabel1_2->setPixmap(*imagen); }

6.2.3.3.

void sbcl_principal::slt_xcircuit () [virtual, slot]

Slot encargado de abrir el Xcircuit para realizar el diseño del circuito a través de la librería de elementos elaborada para Ávalon. Definición en la línea 446 del archivo sbcl_principal.cpp. 447 448 449 450

{ if (!fork()){system("xcircuit");exit(1);} wait(); }

6.2.3.4.

void sbcl_principal::slt_analisis () [virtual, slot]

Slot que se encarga de verificar que está seleccionado en tipo de análisis para así indicar a Ávalon como ha de comportarse en el análisis. Básicamente lo que hace es modificar los valores de unas variables en la clase basicos DATOS cuando el usuario cliquea en trasitorio o estacionario. Definición en la línea 418 del archivo sbcl_principal.cpp. 419 420 421 422 423 424 425

{ basicos *p_DATOS;p_DATOS=&DATOS; QCheckBox *state=cb_trans; if(state->isChecked()){p_DATOS->transitorio=1;} QCheckBox *state2=cb_esta; if(state2->isChecked()){p_DATOS->estacionario=1;} }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

6.2.3.5.

void sbcl_principal::slt_solEstacionario (basicos ∗ p_DATOS) [virtual, slot]

Este Slot se encarga de escribir en pantalla la solución del sistema estacionario. Parámetros: p_DATOS Puntero a estructura basicos Definición en la línea 213 del archivo sbcl_principal.cpp. 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232

{ p_DATOS->file_sol_permanente.replace( ".spc", ".data" ); QStringList lines; QFile file( "sol_perm.data" ); if ( file.open( IO_ReadOnly ) ) { QTextStream stream( &file ); QString line; while ( !stream.atEnd() ) { line = stream.read(); textEdit2->setText(line); lines += line; } file.close(); } //system("rm sol_perm.data x_perm.data"); }

6.2.3.6.

void sbcl_principal::slt_calculadora () [virtual, slot]

Este Slot se encarga de lanzar una calculadora para posibles cálculos que el usuario pueda necesitar. Definición en la línea 458 del archivo sbcl_principal.cpp. 459 460 461 462

{ if (!fork()){system("kcalc");exit(1);} wait(); }

6.2.3.7.

void sbcl_principal::slt_prepara () [virtual, slot]

Este slot se encarga preparar la tabla de condiciones iniciales Entre las tareas que realiza este slot se encuentra: . Preparar la tabla de Condiciones Iniciales calculando cuantas se deben introducir. Escribir en pantalla las variables que calculará el sistema y por lo tanto las condiciones iniciales que deben introducirse. Poner en la pestaña en la que se encuentra un gráfico del circuito para que el usuario se guíe mejor en la introducción de las CI Ver también: mostrar_CI

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

Definición en la línea 146 del archivo sbcl_principal.cpp. 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176

{ basicos *p_DATOS=&DATOS; QPixmap *imagen; //Nos encargamos de preparar la tabla para las condiciones iniciales int *num_line_total_p=&DATOS.elementos; dimensiona(num_line_total_p,p_DATOS); mostrar_CI(p_DATOS); tablex0->insertRows(0,p_DATOS->filas()); //Escritura en pantalla de las variables que se calcularan en el sistema QStringList lines; QFile file( "CI.data" ); if ( file.open( IO_ReadOnly ) ) { QTextStream stream( &file ); QString line; while ( !stream.atEnd() ) { line = stream.read(); textEdit2->setText(line); lines += line; } file.close(); } system("rm CI.data"); QString nombre_imagen=p_DATOS->file_png; imagen=new QPixmap(nombre_imagen); pixmapLabel1_2_2->setPixmap(*imagen); }

6.2.3.8.

void sbcl_principal::slt_nuevoanalisis () [virtual, slot]

Este slot se encarga purgar los valores necesarios para comenzar con un análisis de un nuevo circuito. Definición en la línea 178 del archivo sbcl_principal.cpp. 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202

{ //int num_filas=DATOS.elementos; int num_filas=tableMDG->numRows (); for (int k=0;k<5;k++){ for(int i=0;i<=num_filas+1;i++) {tableMDG->removeRow (i);tableMN->removeRow (i); tableMVC->removeRow (i);tablex0->removeRow (i);}} DATOS.file_spc="";DATOS.file_sol_permanente=""; DATOS.file_png="";DATOS.file_sol_permanente=""; DATOS.datos_perm="";DATOS.datos_trans=""; DATOS.datos_script="";DATOS.solucion="";DATOS.sol_trans="";DATOS.sol_perm=""; DATOS.elementos=0; DATOS.EA=0; DATOS.nodos=0;DATOS.A2=0; DATOS.estacionario=0; DATOS.transitorio=0; DATOS.h=0;DATOS.theta=0;DATOS.t0=0;DATOS.tf=0;DATOS.numv=0; DATOS.t=0; DATOS.densidad=0;DATOS.dispersion=0;DATOS.iter=0;DATOS.estaT=0; DATOS.apuntaEA=0;DATOS.apuntaA2=0; VecDestroy(DATOS.W);VecDestroy(DATOS.Wn); VecDestroy(DATOS.Wn1);VecDestroy(DATOS.x_perm); VecDestroy(DATOS.x_trans); VecDestroy(DATOS.xn);VecDestroy(DATOS.x0); MatDestroy(DATOS.T);MatDestroy(DATOS.G);MatDestroy(DATOS.C); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

6.2.3.9.

void sbcl_principal::slt_gnuplot () [virtual, slot]

Slot encargado de abrir el GNUPlot para realizar nuevos ploteos tras adaptar el script realizado por defecto. Definición en la línea 452 del archivo sbcl_principal.cpp. 453 454 455 456

{ if (!fork()){system("konsole -e gnuplot");exit(1);} wait(); }

6.2.3.10.

void sbcl_principal::slt_sobreQt () [virtual, slot]

Slot encargado de lanzar el diálogo de información de la versión de Qt utilizada. Definición en la línea 475 del archivo sbcl_principal.cpp. 476 { 477 QMessageBox::aboutQt( this, "Intefaz creada con Qt" ); 478 }

6.2.3.11.

void sbcl_principal::slt_ayuda () [virtual, slot]

Slot encargado de abrir diálogo de información sobre el programa. Definición en la línea 464 del archivo sbcl_principal.cpp. 465 466 467 468 469 470 471 472 473

{

QMessageBox::about( this, "Ayuda de Avalon", "PFC:\nSoftware de analisis de circuitos lineales\n" "mediante metodos avanzados de resolucion\npara uso docente\n\n" "Manual de usuario del programa\ny mas info disponibles""\n" "en la web http://avalon-alp.es"); }

6.2.3.12.

void sbcl_principal::slt_sistemaestacionario () [virtual, slot]

Slot que carga el sistema a resolver del estacionario en pantalla. Definición en la línea 480 del archivo sbcl_principal.cpp. 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499

{ //Escritura en pantalla de las variables que se calcularan en el sistema QStringList lines; QFile file( "Datos_x_perm.data" ); if ( file.open( IO_ReadOnly ) ) { QTextStream stream( &file ); QString line; while ( !stream.atEnd() ) { line = stream.read(); textEdit_sistemaestacionario->setText(line); lines += line; } file.close(); } //system("rm Datos_x_perm.data"); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

Referencia de la Estructura sbcl_principal

6.2.3.13.

void sbcl_principal::slt_sistematransitorio () [virtual, slot]

Slot que carga los sistemas a resolver del transitorio en pantalla. Definición en la línea 501 del archivo sbcl_principal.cpp. 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520

{ //Escritura en pantalla de las variables que se calcularan en el sistema QStringList lines; QFile file( "Datos_x_trans.data" ); if ( file.open( IO_ReadOnly ) ) { QTextStream stream( &file ); QString line; while ( !stream.atEnd() ) { line = stream.read(); textEdit_sistematransitorio->setText(line); lines += line; } file.close(); } //system("rm Datos_x_trans.data"); }

6.2.3.14.

void sbcl_principal::slt_solucionestacionario () [virtual, slot]

Slot que carga la solución del estacionario en pantalla. Definición en la línea 522 del archivo sbcl_principal.cpp. 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542

{ //Escritura en pantalla de las variables que se calcularan en el sistema basicos *p_DATOS=&DATOS; QStringList lines; QFile file( p_DATOS->datos_perm ); if ( file.open( IO_ReadOnly ) ) { QTextStream stream( &file ); QString line; while ( !stream.atEnd() ) { line = stream.read(); textEdit09_solucionestacionario->setText(line); lines += line; } file.close(); } system("rm sol_perm.data"); }

6.2.3.15.

void sbcl_principal::slt_soluciontransitorio () [virtual, slot]

Slot que carga la solución del transitorio en pantalla. Definición en la línea 544 del archivo sbcl_principal.cpp. 545 { 546 //Escritura en pantalla de las variables que se calcularan en el sistema 547 basicos *p_DATOS=&DATOS;

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

6.2

548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564

Referencia de la Estructura sbcl_principal

QStringList lines; QFile file( p_DATOS->datos_trans ); if ( file.open( IO_ReadOnly ) ) { QTextStream stream( &file ); QString line; while ( !stream.atEnd() ) { line = stream.read(); textEdit_soluciontransitorio->setText(line); lines += line; } file.close(); } //system("rm sol_trans.data"); }

6.2.3.16.

void sbcl_principal::slt_cargagrafico () [virtual, slot]

Este slot abre el gráfico realizado con el script por defecto en pantalla. Definición en la línea 566 del archivo sbcl_principal.cpp. 567 568 569 570 571 572 573

{ basicos *p_DATOS=&DATOS; QString grafica = p_DATOS->solucion; grafica.prepend("kview "); if (!fork()){system(grafica);exit(1);} wait(); }

6.2.3.17.

void sbcl_principal::slt_abrescript () [virtual, slot]

Este slot abre el script que usa GNUPlot para generar el gráfico final de las variables calculadas. Definición en la línea 575 del archivo sbcl_principal.cpp. 576 577 578 579 580 581 582

{ basicos *p_DATOS=&DATOS; QString comando=script(p_DATOS); if (!fork()){system(comando);exit(1);} wait(); }

6.2.3.18.

void sbcl_principal::slt_vermatrizT () [virtual, slot]

Este slot abre una visualización gráfica de la matriz sparse. Definición en la línea 584 del archivo sbcl_principal.cpp. 585 586 587 588

{ basicos *p_DATOS=&DATOS; MatView(p_DATOS->T,PETSC_VIEWER_DRAW_WORLD ); }

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

7 Documentación de archivos

6.2.3.19.

void sbcl_principal::INFOgeneral (basicos ∗ DATOS) [virtual, slot]

Slot escargado de visualizar datos generales del circuito que se está analizando. Definición en la línea 590 del archivo sbcl_principal.cpp. 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621

{ QString line; QString salto=("\n"); int elementos=DATOS->elementos; int EA=DATOS->EA; QString sEA("EA: "); int nodos=DATOS->nodos;QString sNodos("Nodos: "); int A2=DATOS->A2;QString sA2("A2: "); int NOnulos=DATOS->nocero;QString sNonulos("No nulos: "); double densidad=DATOS->densidad;QString sdensidad("Densidad: "); double dispersion=DATOS->dispersion;QString sdispersion("Dispersion: "); //Calculo de la densidad y dispersión de la matriz T MatInfo info; MatGetInfo(DATOS->T,MAT_LOCAL,&info); DATOS->nocero=info.nz_used; DATOS->densidad=info.nz_used/(DATOS->filas()*DATOS->columnas()); DATOS->dispersion=1-DATOS->densidad; line= QString("Elementos del Cto: "); QString valor,valor1,valor2,valor3,valor4,valor5,valor6; valor.setNum (elementos, 10);line.append(valor);line.append(salto); valor1.setNum (EA, 10);line.append(sEA);line.append(valor1);line.append(salto); valor2.setNum (nodos, 10);line.append(sNodos);line.append(valor2);line.append(salto); valor3.setNum (A2, 10);line.append(sA2);line.append(valor3);line.append(salto); valor4.setNum (NOnulos, 10);line.append(sNonulos);line.append(valor4);line.append(salto); valor5.setNum (densidad,’g’, 6); line.append(sdensidad);line.append(valor5);line.append(salto); valor6.setNum (dispersion,’g’, 10); line.append(sdispersion);line.append(valor6);line.append(salto); te_infogeneral->setText(line); }

6.2.4.

Documentación de los datos miembro

6.2.4.1.

basicos sbcl_principal::DATOS

Definición en la línea 35 del archivo sbcl_principal.h. La documentación para esta estructura fue generada a partir de los siguientes ficheros: Programacion/AVALON/src/sbcl_principal.h Programacion/AVALON/src/sbcl_principal.cpp

7. 7.1.

Documentación de archivos Referencia del Archivo Programacion/AVALON/src/cabeceras.h

#include "petsc.h" #include "petscmat.h" #include "petscvec.h" #include "petscksp.h" #include "petscerror.h" Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

7.1

Referencia del Archivo Programacion/AVALON/src/cabeceras.h

#include <iostream> #include <fstream> #include <cstdlib> #include <stdio.h> #include <stdlib.h> #include "sbcl_principal.h" #include "dlg_avalon.h" #include <kapplication.h> #include <kaboutdata.h> #include <kcmdlineargs.h> #include <klocale.h> #include <qlineedit.h> #include <qfiledialog.h> #include <qstring.h> #include <qimage.h> #include <qrect.h> #include <qpainter.h> #include <qiodevice.h> #include <qfile.h> #include <qtextstream.h> #include <qwidget.h> #include <qtable.h> #include <qprocess.h> #include <qcstring.h> #include <qmessagebox.h> #include <qcheckbox.h> #include <qtextedit.h> #include <qdatatable.h> #include <qhttp.h> #include <qsplashscreen.h> #include <qtimer.h> #include <qsimplerichtext.h> #include <gsl/gsl_sf_bessel.h> #include <gsl/gsl_complex.h> #include <gsl/gsl_complex_math.h> #include <complex.h>

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

7.2

Referencia del Archivo Programacion/AVALON/src/elementos.cpp

#include <gsl/gsl_matrix.h> #include <gsl/gsl_vector.h> Dependencia gráfica adjunta para cabeceras.h: Programacion/AVALON/src/cabeceras.h

petsc.h

petscmat.h

petscvec.h

petscksp.h

petscerror.h

iostream

fstream

cstdlib

stdio.h

stdlib.h

sbcl_principal.h

dlg_avalon.h

kapplication.h

kaboutdata.h

kcmdlineargs.h

klocale.h

qlineedit.h

qfiledialog.h

qstring.h

qimage.h

qrect.h

qpainter.h

qiodevice.h

qfile.h

qtextstream.h

qwidget.h

qtable.h

qprocess.h

qcstring.h

qmessagebox.h

qcheckbox.h

qtextedit.h

qdatatable.h

qhttp.h

qsplashscreen.h

qtimer.h

qsimplerichtext.h

gsl/gsl_sf_bessel.h

gsl/gsl_complex.h

gsl/gsl_complex_math.h

complex.h

gsl/gsl_matrix.h

gsl/gsl_vector.h

gsl/gsl_matrix.h

gsl/gsl_vector.h

estructuras.h

Gráfico de los archivos que directa o indirectamente incluyen a este archivo: Programacion/AVALON/src/cabeceras.h

Programacion/AVALON/src/sbcl_principal.h

Programacion/AVALON/src/estructuras.cpp

Programacion/AVALON/src/elementos.cpp

Programacion/AVALON/src/sbcl_principal.cpp

Definiciones #define PI 3.141592654 #define RAD 0.017453292 #define GRADOS 57.29577951 7.1.1.

Documentación de las definiciones

7.1.1.1.

#define GRADOS 57.29577951

Definición en la línea 81 del archivo cabeceras.h. 7.1.1.2.

#define PI 3.141592654

Definición en la línea 79 del archivo cabeceras.h. 7.1.1.3.

#define RAD 0.017453292

Definición en la línea 80 del archivo cabeceras.h.

7.2.

Referencia del Archivo Programacion/AVALON/src/elementos.cpp

#include "cabeceras.h" #include "elementos.h" Dependencia gráfica adjunta para elementos.cpp: Programacion/AVALON/src/elementos.cpp

cabeceras.h

petsc.h

petscmat.h

petscvec.h

petscksp.h

petscerror.h

iostream

fstream

cstdlib

stdio.h

stdlib.h

sbcl_principal.h

dlg_avalon.h

kapplication.h

kaboutdata.h

kcmdlineargs.h

klocale.h

qlineedit.h

qfiledialog.h

qstring.h

qimage.h

qrect.h

elementos.h

qpainter.h

qiodevice.h

qfile.h

qtextstream.h

qwidget.h

qtable.h

qprocess.h

qcstring.h

qmessagebox.h

qcheckbox.h

qtextedit.h

qdatatable.h

qhttp.h

qsplashscreen.h

qtimer.h

qsimplerichtext.h

gsl/gsl_sf_bessel.h

gsl/gsl_complex.h

gsl/gsl_complex_math.h

complex.h

estructuras.h

Software de análisis de circuitos lineales mediante métodos avanzados de resolución para uso docente. Manual de Código Fuente por Ayose Lomba Pérez

7.2

Referencia del Archivo Programacion/AVALON/src/elementos.cpp

100

Funciones void elementoMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga de seleccionar a que función debe llamarse según el elemento que se este leyendo en tablas.

void conductanciaMatrizT (double ∗p_elemento, basicos ∗p_DATOS) Esta Función se encarga del ensamblaje de valores en la matriz T de la conductancia.