crs.c

Vá para a documentação deste arquivo.

/*
** ---------------------------------------------------------------
** Definições globais:
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#include "crs.h"

/*
** ---------------------------------------------------------------
** Definições e variáveis locais:
*/

typedef struct _crsmember {
 int node0;
 int node1;
 int rotlib0;
 int rotlib1;
 double E;
 double I;
 double q;
 double m0;
 double m1;
} CrsMember;

typedef struct _crsadjmember {
 struct _crsadjmember *next;
 int id;
 double distr;
 double trans;
} CrsAdjMember;

typedef struct _crsnode {
 double x;
 double y;
 int rotlib;
 struct _crsadjmember *adj_head;
} CrsNode;

typedef struct _crsmodel {
 int n_member;
 CrsMember *member;
 int max_members;
 int n_node;
 CrsNode *node;
 int max_nodes;
  double mom_tol;
} CrsModel;

static CrsModel *crs = NULL;

/*
** ---------------------------------------------------------------
** Funções locais: 
*/

/*========================  _crsBuildNodeMemberAdj  =======================*/

static void _crsBuildNodeMemberAdj( void )
{
 CrsAdjMember *adjmember;  /* aponta para uma barra adjacente a um nó */
 int          i;           /* índice de uma barra no vetor de barras */

 for( i = 0; i < crs->n_member; i++ )
 {
  /* Aloca memoria para um registro de barra adjacente para o primeiro
   * nó da barra.  Atribui o índice a barra corrente neste registro.  
   * Inicializa como nulos os valores dos coeficientes de distribuição
   * e transmissão de momentos deste registro.  Insere o registro 
   * no início da lista encadeada de barras adjacentes do primeiro nó
   * da barra.
   */
/**** COMPLETE AQUI: 001 ****/

  /* Aloca memoria para um registro de barra adjacente para o segundo
   * nó da barra.  Atribui o índice a barra corrente neste registro.  
   * Inicializa como nulos os valores dos coeficientes de distribuição
   * e transmissão de momentos deste registro.  Insere o registro 
   * no início da lista encadeada de barras adjacentes do segundo nó
   * da barra.
   */
/**** COMPLETE AQUI: 002 ****/
 }
}

/*==========================  _crsMemberLength  ========================*/

static double _crsMemberLength( int id )
{
 double len;

/**** COMPLETE AQUI: 003 ****/

 return( len );
}

/*==========================  _crsMemberStiffness ========================*/

static double _crsMemberStiffness( int member_id, int node_id )
{
 double       membstiff;   /* coeficiente de rigidez à rotação da barra */

/**** COMPLETE AQUI: 004 ****/

 return( membstiff );
}

/*==========================  _crsMemberTransmission ========================*/

static double _crsMemberTransmission( int member_id, int node_id )
{
 double       membtrans;   /* coeficiente de transmissão de momentos da barra */

/**** COMPLETE AQUI: 005 ****/

 return( membtrans );
}

/*==========================  _crsDistribCoef  ========================*/

static void _crsDistribCoef( void )
{
/**** COMPLETE AQUI: 006 ****/
}

/*==========================  _crsInitMoments  ========================*/

static void _crsInitMoments( void )
{
/**** COMPLETE AQUI: 007 ****/
}
 
/*========================  _crsGetNodeUnbalance  ========================*/

double _crsGetNodeUnbalance( int id )
{
 double       munb;        /* momento desquilibrante do nó */

/**** COMPLETE AQUI: 013 ****/

 return( munb );
}

/*=======================  _crsGetMaxMomNode  ========================*/

static int _crsGetMaxMomNode( void )
{
 int          n = -1;    /* índice do nó com máximo momento desequilibrante */

/**** COMPLETE AQUI: 008 ****/

 return( n );
}
 
/*=========================  _crsProcessNode  =========================*/

static void _crsProcessNode( int n )
{
/**** COMPLETE AQUI: 009 ****/
}


/*
** ---------------------------------------------------------------
** Funções exportadas:
*/

/*=========================  crsInitModel  =========================*/

void *crsInitModel( int max_nodes, int max_members )
{
 CrsModel *crs_model;

 crs_model = (CrsModel *)malloc( sizeof( CrsModel ) );
 if( crs_model == NULL )
  return( NULL );

 crs_model->max_nodes = max_nodes;
 crs_model->node = (CrsNode *)calloc( max_nodes, sizeof( CrsNode ) );
 if( crs_model->node == NULL )
 {
  crsFreeModel( crs_model );
  return( NULL );
 }

 crs_model->max_members = max_members;
 crs_model->member = (CrsMember *)calloc( max_members, sizeof( CrsMember ) );
 if( crs_model->member == NULL )
 {
  crsFreeModel( crs_model );
  return( NULL );
 }

 crs_model->n_node = 0;
 crs_model->n_member = 0;

 return( crs_model );
}

/*=======================  crsActivateModel  =======================*/

void crsActivateModel( void *model )
{
 if( !model )
  return;

 crs = (CrsModel *)model;
}

/*===========================  crsFreeModel  ==========================*/

void crsFreeModel( void *model )
{
/**** COMPLETE AQUI: 010 ****/
}

/*==========================  crsAddNode  =========================*/

int crsAddNode( double x, double y )
{
 int    node_id;

 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

/* Verifica se o número de nós do modelo é igual ao máximo número de
 * nós com que o vetor de nós está dimensionado.  Se este for o caso,
 * dobra o tamanho de dimensionamento e realoca vetor com base no 
 * novo tamanho.
 */
/**** COMPLETE AQUI: 011 ****/

/* Armazena as coordenadas fornecidas no nó corrente.
 * O índice do nó corrente corresponde ao número de nós antes da 
 * chamada desta função.  Incrementa o número total de nós.
 */
 node_id = crs->n_node;
 crs->node[node_id].x = x;
 crs->node[node_id].y = y;
 crs->node[node_id].rotlib = ROT_FREE;
 crs->n_node++;

 return( node_id );
}

/*==========================  crsFixNodeRot  =========================*/

void crsFixNodeRot( int id )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_node) )
  return;

 crs->node[id].rotlib = ROT_FIX;
}

/*==========================  crsFreeNodeRot  =========================*/

void crsFreeNodeRot( int id )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_node) )
  return;

 crs->node[id].rotlib = ROT_FREE;
}

/*==========================  crsAddMember  =========================*/

int crsAddMember( int node0, int node1 )
{
 int    member_id;

 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

/* Verifica se o número de barras do modelo é igual ao máximo número de
 * barras com que o vetor de barras está dimensionado.  Se este for o caso,
 * dobra o tamanho de dimensionamento e realoca vetor com base no 
 * novo tamanho.
 */
/**** COMPLETE AQUI: 012 ****/

/* Armazena os índices dos nós fornecidos na barra corrente.
 * O índice da barra corrente corresponde ao número de barras antes da 
 * chamada desta função.  Incrementa o número total de barras.
 */
 member_id = crs->n_member;
 crs->member[member_id].node0 = node0;
 crs->member[member_id].node1 = node1;
 crs->member[member_id].rotlib0 = ROT_FIX;
 crs->member[member_id].rotlib1 = ROT_FIX;
 crs->n_member++;

 return( member_id );
}

/*==========================  crsFixMemberEndRot  =========================*/

void crsFixMemberEndRot( int id, int end )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 if( end = 0 )
  crs->member[id].rotlib0 = ROT_FIX;
 else
  crs->member[id].rotlib1 = ROT_FIX;
}

/*==========================  crsFreeMemberEndRot  =========================*/

void crsFreeMemberEndRot( int id, int end )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 if( end = 0 )
  crs->member[id].rotlib0 = ROT_FREE;
 else
  crs->member[id].rotlib1 = ROT_FREE;
}

/*==========================  crsMemberElasticity  =========================*/

void crsMemberElasticity( int id, double E )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 crs->member[id].E = E;
}

/*==========================  crsMemberInertia  =========================*/

void crsMemberInertia( int id, double I )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 crs->member[id].I = I;
}

/*==========================  crsMemberUnifLoad  =========================*/

void crsMemberUnifLoad( int id, double q )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 crs->member[id].q = q;
}

/*==========================  crsCompleteModel  ===========================*/

int crsCompleteModel( void )
{
 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

 _crsBuildNodeMemberAdj( );
 _crsDistribCoef( );

 return( CRS_SUCCESS );
}

/*==========================  crsResetSolution  ===========================*/

int crsResetSolution( double mom_tol )
{
 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

 crs->mom_tol = mom_tol;

 _crsInitMoments( );

 return( CRS_SUCCESS );
}

/*============================  crsSolveModel  =============================*/

int crsSolveModel( void )
{
 int  n;  /* indice do no' para processar */
 int  did_one_step = 0;

 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

 while( (n = _crsGetMaxMomNode()) != -1 )
 {
  did_one_step = 1;
  _crsProcessNode( n );
 }

 if( ! did_one_step )
  return( CRS_NO_STEP_TO_GO );

 return( CRS_SUCCESS );
}
 
/*=========================  crsStepSolution  =========================*/

int crsStepSolution( void )
{
 int  n;  /* indice do no' para processar */

 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

 if( (n = _crsGetMaxMomNode()) == -1 )
  return( CRS_NO_STEP_TO_GO );

 _crsProcessNode( n );

 return( CRS_SUCCESS );
}
 
/*========================  crsChkNodeUnbalance  ========================*/

int crsChkNodeUnbalance( int id )
{
 double       munbabs;   /* momento desquilibrante do nó em valor absoluto */

 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

 if( crs->node[id].rotlib == ROT_FREE )
 {
  munbabs = _crsGetNodeUnbalance( id );
  munbabs = fabs( munbabs );

  if( munbabs > crs->mom_tol )
  {
   return( CRS_SUCCESS );
  }
 }
 else
 {
  return( CRS_FIXED_NODE );
 }

 return( CRS_NO_STEP_TO_GO );
}
 
/*=========================  crsProcessNode  =========================*/

int crsProcessNode( int id )
{
 int    status;

 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

 status = crsChkNodeUnbalance( id );
 if( status != CRS_SUCCESS )
  return( status );

 _crsProcessNode( id );

 return( CRS_SUCCESS );
}

/*===========================  crsGetNumNodes  ============================*/

int crsGetNumNodes( void )
{
 if( !crs )
  return( 0 );

 return( crs->n_node );
}

/*==========================  crsGetNodeCoords  =========================*/

void crsGetNodeCoords( int id, double *x, double *y )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_node) )
  return;

 *x = crs->node[id].x;
 *y = crs->node[id].y;
}

/*===========================  crsGetNumMembers  ============================*/

int crsGetNumMembers( void )
{
 if( !crs )
  return( 0 );

 return( crs->n_member );
}

/*==========================  crsGetMemberNodes  =========================*/

void crsGetMemberNodes( int id, int *node0, int *node1 )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 *node0 = crs->member[id].node0;
 *node1 = crs->member[id].node1;
}

/*==========================  crsGetMemberRotLibs  =========================*/

void crsGetMemberRotLibs( int id, int *rotlib0, int *rotlib1 )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 *rotlib0 = crs->member[id].rotlib0;
 *rotlib1 = crs->member[id].rotlib1;
}

/*==========================  crsGetMemberUnifLoad  =========================*/

void crsGetMemberUnifLoad( int id, double *q )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 *q = crs->member[id].q;
}

/*==========================  crsGetMemberMoments  =========================*/

void crsGetMemberMoments( int id, double *m0, double *m1 )
{
 if( !crs )
  return;

 if( (id < 0) || (id >= crs->n_member) )
  return;

 *m0 = crs->member[id].m0;
 *m1 = crs->member[id].m1;
}

/*===========================  crsGetGlobalBox  ==========================*/

int crsGetGlobalBox( double *xmin, double *xmax, double *ymin, double *ymax )
{
 int          i;         /* índice de um nó no vetor de nós do modelo */

 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

 if( crs->n_node < 1 )
  return( CRS_NO_MODEL_DEFINED );

 *xmin = *xmax = crs->node[0].x;
 *ymin = *ymax = crs->node[0].y;
 for( i = 1; i < crs->n_node; i++ )
 {
  if( crs->node[i].x < *xmin ) 
   *xmin = crs->node[i].x;
  if( crs->node[i].x > *xmax ) 
   *xmax = crs->node[i].x;
  if( crs->node[i].y < *ymin ) 
   *ymin = crs->node[i].y;
  if( crs->node[i].y > *ymax ) 
   *ymax = crs->node[i].y;
 }

 return( CRS_SUCCESS );
}

/*===========================  crsPickNode  ==========================*/

int crsPickNode( double x, double y, double tol )
{
 int          i;         /* índice de um nó no vetor de nós do modelo */

 if( !crs )
  return( CRS_NO_MODEL_DEFINED );

 for( i = 0; i < crs->n_node; i++ )
 {
  if( (fabs( crs->node[i].x - x ) <= tol)  &&
      (fabs( crs->node[i].y - y ) <= tol) )
  {
   return( i );
  }
 }

 return( CRS_FAILURE );
}

---