Métodos de resolución

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

Módulos
	Resolución de Permanente
	Resolución de Transitorio
	Resultados
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.

---

Descripción detallada

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

---

Slots públicos

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.

{
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;
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);
                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);                
        }
}
escribirgnuplot(p_DATOS);
//llamada a salida de datos
slt_resolucion(p_DATOS);
}
}

---

Slots protegidos

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.

{
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);
}