stdve.c

Go to the documentation of this file.

/*
%M This modules contains the driver methods to solve a problem using the 
   dynamic relax algorithm with visco elastic materials.
%a Joao Luiz Elias Campos.
%d June 20th, 2000.
%r $Id: stdve.c,v 1.1 2004/06/22 05:29:59 joaoluiz Exp $
%w (C) COPYRIGHT 1995-1996, Eduardo Nobre Lages.
   (C) COPYRIGHT 1997-2000, Joao Luiz Elias Campos.
   All Rights Reserved
   Duplication of this program or any part thereof without the express
   written consent of the author is prohibited.
*
*  Modified: 28-Apr-2005    Alexandre A. Del Savio
*    Foram substituídas todas as alocações dinâmicas feitas com malloc 
*    por calloc.
*
*  Modified: 23-Fev-2006    Juan Pablo Ibañez
*    Modificada a funcão StandardVEAnalysis que passa a retornar un valor int.       
*/

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

#include "drv.h"
#include "fem.h"
#include "load.h"
#include "elm.h"
#include "node.h"
#include "alg.h"
#include "rio.h"
#include "nfi.h"
#include "load.h"
#include "xgplib.h"


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

/*
** ------------------------------------------------------------------------
** Local functions:
*/
static void StandardVEViscoForces( double * );
static void StandardVENew        ( sDriver ** );
static void StandardVEFree       ( sDriver * );
static int  StandardVEAnalysis   (UI_State *);
static int  StandardVEPrintResult( int, double *, double * );


/*
%F
*/
static void StandardVEViscoForces( double *U )
{
 int     i, j, num, id;
 int     inc[8];
 sTensor stress[8], strain[8];
 double  vforce[24];

/* Loop over the elements
 */
 for( i = 0; i < NumElements; i++ )
 {
 /* Check to see if the element was not rezoned
  */
  if( ElmList[i]->rezone != NONE )
   continue;

 /* Compute element stress strain
  */
  ElmStressStrain( ElmList[i], 0.0, U, 0L, stress, strain );

 /* Compute element visco forces
  */
  ElmViscoForce( ElmList[i], Config.timeStep, stress, vforce );

 /* Add to the node information
  */
  ElmConnect( ElmList[i], inc );
  ElmNumNodes( ElmList[i], &num );
  for( j = 0; j < num; j++ )
  {
   id = inc[j] - 1;
   if( NodeVector[id].rezone == NONE )
   {
    if( NodeVector[id].dof.x == FORCE )
     NodeVector[id].dof.vpx += vforce[NDof*j];

    if( NodeVector[id].dof.y == FORCE ) 
     NodeVector[id].dof.vpy += vforce[NDof*j+1];

    if( NDof == 3 )
     if( NodeVector[id].dof.z == FORCE )
      NodeVector[id].dof.vpz += vforce[NDof*j+2];
   }
  }
 }
 
} /* End of StandardVEViscoForces */


/*
%F
*/
static void StandardVENew( sDriver **drv )
{
/* Get memory for the driver descriptor
 */
 (*drv) = (sDriver *)calloc(1, sizeof(sDriver));

/* Fill up driver descriptor
 */
 (*drv)->type = STANDARD_VE;

} /* End of StandardVENew */


/*
%F
*/
static void StandardVEFree( sDriver *drv )
{
/* Reset driver data
 */
 drv->data = 0L;

} /* End of StandardVEFree */


/*
%F This function process the probleam analysis using a dynamic relax 
   algorithm.
*/
static int StandardVEAnalysis(UI_State *R)
{
 int     i, n;
 double  time, disp;
 double *F  = 0L;
 double *U  = 0L;
 double *V  = 0L;
 double *M  = 0L;
 double *dU = 0L;
 
/* Get memory for the vectors used during the analysis
 */
 F  = (double *)calloc( NDof*NumNodes, sizeof(double) );
 U  = (double *)calloc( NDof*NumNodes, sizeof(double) );
 V  = (double *)calloc( NDof*NumNodes, sizeof(double) );
 M  = (double *)calloc( NDof*NumNodes, sizeof(double) );
 dU = (double *)calloc( NDof*NumNodes, sizeof(double) );

/* Start graphic module
 */
 XGPBegin( );

/* Print feedback message
 */
 printf( "\tSolve problem........................:\n" );
 fflush( stdout );

/* For each time step
 */
 for( time = 0.0; time <= Config.totalTime; time += Config.timeStep )
 {
 /* Apply prescribed values
  */
  PrescribedValues( );

 /* Add visco forces
  */
  StandardVEViscoForces( U );

 /* Print feedback message
  */
  printf( "\tTotal time...........................: %f\n", time );
  fflush( stdout );

 /* Reset all vectors 
  */
  F  = (double *)memset( (void *)F, 0, NDof*NumNodes*sizeof(double) );
  V  = (double *)memset( (void *)V, 0, NDof*NumNodes*sizeof(double) );
  M  = (double *)memset( (void *)M, 0, NDof*NumNodes*sizeof(double) );
  dU = (double *)memset( (void *)dU, 0, NDof*NumNodes*sizeof(double) );

 /* Call the dynamic relaxation algorithm
  */
  if( !DRSolver(R, F, dU, V, M, 0) )
  {
   IoCloseFiles( );
   IoCloseTempFile( );
   return 0;
  }

 /* Update displacement vector
  */
  for( i = 0; i < NDof*NumNodes; i++ )
   U[i] += dU[i];

 /* Plot displacement x time
  */
  if( (NumCurves != 0) && (GpType == 4) )
  {
   for( n = 0; n < NumNodes; n++ )
   {
    disp  = U[NDof*n] * U[NDof*n];
    disp += U[NDof*n+1] * U[NDof*n+1];
    if( NDof == 3 )
     disp += U[NDof*n+2] * U[NDof*n+2];
    if( NodeVector[n].dspTime == DSP_YES )
     XGPSendPoint( NodeVector[n].curve, time, sqrt(disp) );
   }
  }

 /* Update number of time steps
  */
  Config.num_time_step++;

 /* Write results on a temporary file
  */
  if( !IoStartSave( ) ) return 0;

  fwrite( U, sizeof(double), NDof*NumNodes, ndlr );
  fflush( ndlr );

  for( i = 0; i < NumElements; i++ )
   ElmWriteStress( ElmList[i], elmr, U, V );
  fflush( elmr );
 }

/* Finish graphic module
 */
 XGPEnd( );

/* Release memory
 */
 free( F );
 free( U );
 free( V );
 free( M );
 free( dU );

 return 1;

} /* End of StandardVEAnalysis */


/*
%F
*/
static int  StandardVEPrintResult( int iteration, double *U, double *V )
{
 return 1;
} /* End of StandardVEPrintResult */


/*
** ------------------------------------------------------------------------
** Public functions:
*/

/*
%F This function initializes the sub-class STANDARD_VE.
*/
void StandardVEInit( void );
void StandardVEInit( void )
{
/* Initialize STANDARD_VE driver sub-class
 */
 DrvClass[STANDARD_VE].new      = StandardVENew;
 DrvClass[STANDARD_VE].free     = StandardVEFree;
 DrvClass[STANDARD_VE].analysis = StandardVEAnalysis;
 DrvClass[STANDARD_VE].printres = StandardVEPrintResult;

} /* End of StandardVEInit */


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

---