csr.c

Go to the documentation of this file.

/*
%M Esse módulo contem as funções para montagem da matriz de rigidez
 * no formato compressed sparse row
 *     06-07 André Luis Muller
 *
 */

/*
** ------------------------------------------------------------------------
** Global variables and symbols:
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "elm.h"
#include "node.h"
#include "alg.h"
#include "fem.h"
#include "csr.h"

/*
** ------------------------------------------------------------------------
** Local variables and symbols:
*/


/*
** ------------------------------------------------------------------------
** Local functions:
*/


/*
%F
*/
void BuildIaVec(CsrNode *node_list, int *ia, int nnu, int *nna)
{
 /* esta função controi o vetor ia do formato CSR
 */

 /* inicia nna
 */
 *nna = 0;
 
 /* constroi o vetor ia
 */
 BuildIaVector(node_list, nnu, nna, ia);

}
/* fim da função BuildIaVector */

/*
%F
*/
void BuildJaVec(CsrNode *node_list, int *ja)
{
 /* esta função controi o vetor ja do formato CSR
 */

 /* constroi o vetor ja
 */
 BuildJaVector(node_list, ja);

 
}
/* fim da função BuildJaVector */

/*=====================  BuildNodeList ======================*/

void BuildNodeList( CsrNode *node_list )
{
 int       elem;                  /* elemento corrente             */
 int       node;                  /* nó corrente                   */
 int       next;                  /* next                          */
 int       j,k;                   /* índice                        */
 int       inc[8];                /* incidência                    */
 int       index;                 /* número de nós do elemento     */
 
 /* loop para todos os elementos
 */
 for( elem = 0; elem < NumElements; elem++ ){  
  /* pega o num. de nós e os nós do elemento 
  */
  ElmGetInc(ElmList[elem], inc, &index);
  for( j = 0; j < index; j++ ){
   node = inc[j];
   for( k = 0; k < index; k++ ){
    if(k != j){
     next = inc[k];
     /* coloca o nó na lista
     */
     mshAddAdjNode( &node_list[node], next );
    }
   }
  }
 }
}

/* fim da função BuildNodeList */

/*=====================  BuildIaVector  ======================*/

void BuildIaVector(CsrNode *node_list, int nnu, int *nna, int *ia )
{
 /* essa função cria o vetor ia do formato CSR
 */
 int       i,j,k;                     
 AdjNode   *adjnode;
 AdjNode   *adjnodehead;
 int       nn;

 /* inicia variáveis
 */
 k = 1;
 
 /* seta a possição 0 do vetor ia
 */
 ia[0] = 0;

 /* percorre a lista de nós
 */
 if( node_list != NULL ){
  for ( j = 0; j < NumNodes; j++) {
   nn = 0;
   adjnodehead = node_list[j].adj_head;
   while ( adjnodehead != NULL ){
    adjnode = adjnodehead;
    adjnodehead = adjnode->next; 
    nn ++;
   }
   /* adiciona os termos de todos os
   graus de liberdade
   */
   for ( i = 0; i < NDof; i++) {
    ia[k] = ia[k-1] + (nn + 1) * NDof;
    k ++;
   }
   /* incrementa nna
   */
   *nna += ((nn + 1) * NDof) * NDof;
  }
 }

 /* seta o valor para o último termo do
    vetor ia
    */
 ia[nnu] = *nna;
}

/* fim da função BuildIaVector */

/*=====================  BuildJaVector  ======================*/

void BuildJaVector(CsrNode *node_list, int *ja )
{
 /* essa função cria o vetor ja do formato CSR
 */
 int       i,j,l,m;                     
 AdjNode   *adjnode;
 AdjNode   *adjnodehead;
 int       nv, cja[200];

 /* inicia l
 */
 l = 0;

 /* percorre a lista de nós
 */
 if( node_list != NULL ){
  for ( j = 0; j < NumNodes; j++) {
   nv = 0;
   for ( i = 0; i < NDof; i++) {
    ja[l] = cja[nv] = NDof*j+i;
    l ++;
    nv ++;
   }
   adjnodehead = node_list[j].adj_head;
   while ( adjnodehead != NULL ){
    adjnode = adjnodehead;
    for ( i = 0; i < NDof; i++) {
     ja[l] = cja[nv] = NDof*adjnodehead->id+i;
     l ++;
     nv ++;
    }
    adjnodehead = adjnode->next; 
   }
   /* adiciona os termos de todos os 
      graus de liberdade
   */
   for ( i = 0; i < (NDof - 1); i++) {
    for ( m = 0; m < nv; m++) {
     /* faz a correção do primeiro termo de cada linha
     */
     if(m == 0){
      if(i == 0){
       ja[l] = cja[1];
       l ++;
       ja[l] = cja[0];      
       m++;
      }
      /* se NDof maior que 2
      */
      else{
       ja[l] = cja[2];
       l ++;
       ja[l] = cja[1]; 
       l ++;
       ja[l] = cja[0];     
       m = 2;
      } 
     }
     else{
      ja[l] = cja[m];
     }
     /* incrementa l
     */
     l ++;
    }
   }
  }
 }
}

/* fim da função BuildJaVector */

/*========================  mshAddAdjNode  ========================*/

void mshAddAdjNode( CsrNode *node, int adj_id )
{
 /* essa função cria a lista de adjacências de todos
    os nós da malha de elementos finitos
 */
 AdjNode   *newadj;             
 AdjNode   *adjnode;            
 int       found = 0;           
 
 adjnode = node->adj_head;                    /* inicializa adjnode*/
 while( adjnode != NULL)                      /* loop enquanto adjnode diferente de NULL(zero),ou seja, percorre toda a lista*/
 {                                             
  if( adjnode->id == adj_id )                 /* testa índice*/
  {
   found=1;
   break;                                      
  }
  adjnode = adjnode->next;                    /* incrementa adjnode apontando para o seguinte*/
 }
 if(!found){
  newadj=(AdjNode *)malloc(sizeof(AdjNode));  /* Aloca memória dinâmicamente*/                                              
  newadj->next=node->adj_head;                /* nova adj aponta para cabeçário*/
  newadj->id=adj_id;                          /* indexa nó à lista*/ 
  node->adj_head = newadj;
 } 
}

/* fim da função mshAddAdjNode */

/*========================  FreeNodeList  =========================*/

void FreeNodeList( CsrNode *node_list )
{
 AdjNode   *adjnode;    /* auxiliar adjacent node pointer   */
 int       i;           /* counter                          */

 if( node_list != NULL ){
  for ( i = 0; i < NumNodes; i++)        /* loop para todos os nós */
   while ( node_list[i].adj_head != NULL ){
    adjnode = node_list[i].adj_head;
    node_list[i].adj_head = adjnode->next;
    free (adjnode);                      /* libera memoria da lista de nós adjacentes */
   }
  free (node_list);             
 }
 node_list = NULL;
}

/* fim da função FreeNodeList */

/*=====================  BuildaVector  ======================*/

int BuildaVector(int i, int j, double coef, int *ia, int *ja, double *avector )
{
 /* essa função coloca os termos da matriz global
    no vetor avector segundo o formato CSR
 */
 int k;
 /* percorre cada linha da matriz global*/
 for( k = 0; k < (ia[i + 1] - ia[i]); k++ ){
  if(ja[ia[i]+k] == j){
   /* monta o vetor de coeficientes*/
   avector[ia[i]+k] += coef;
   return(1);
  }
 }
 return (0);
}

/* fim da função BuildaVector */

/* =======================================================  End of File  */

---