stdveflc.c

Go to the documentation of this file.

/*
%M This modules contains the driver methods to solve a problem using the 
   dynamic relax algorithm for the visco elastic materials (FLAC 
   implementation).
%a Joao Luiz Elias Campos.
%d September 16th, 2000.
%r $Id: stdveflc.c,v 1.1 2004/06/22 05:29:59 joaoluiz Exp $
%w (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 StandardVEFlacAnalysis, que passa a retornar  
*    un valor int.         
* 
*  Modified: 23-Fev-2006    Juan Pablo Ibanez
*    Modificada a funcao StandardVEFlacPrintResult, qua passou a incluir
*    sempre a primeira iteracao para geracao do arquivo neutro.
*/

/*
** ------------------------------------------------------------------------
** Global variables and symbols:
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.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 StandardVEFlacNew        ( sDriver ** );
static void StandardVEFlacFree       ( sDriver * );
static int  StandardVEFlacAnalysis   (UI_State *);
static int  StandardVEFlacPrintResult( int, double *, double * );


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

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

} /* End of StandardVEFlacNew */


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

} /* End of StandardVEFlacFree */


/*
%F This function process the probleam analysis using a dynamic relax 
   algorithm.
*/
static int StandardVEFlacAnalysis(UI_State *R)
{
 int     i;
 double *FVector = 0L;
 double *UVector = 0L;
 double *VVector = 0L;
 double *MVector = 0L;
 
/* Get memory for the vectors used during the analysis
 */
 FVector = (double *)calloc( NDof*NumNodes, sizeof(double) );
 UVector = (double *)calloc( NDof*NumNodes, sizeof(double) );
 VVector = (double *)calloc( NDof*NumNodes, sizeof(double) );
 MVector = (double *)calloc( NDof*NumNodes, sizeof(double) );

/* Apply prescribed values
 */
 PrescribedValues( );

/* Start graphic module
 */
 XGPBegin( );

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

/* Call the dynamic relaxation algorithm
 */
 if( !DRSolver(R, FVector, UVector, VVector, MVector, 0) ) return 0;

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

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

 for( i = 0; i < NumElements; i++ )
  ElmWriteStress( ElmList[i], elmr, UVector, VVector );
 fflush( elmr );

/* Finish graphic module
 */
 XGPEnd( );

/* Release memory
 */
 free( FVector );
 free( UVector );
 free( VVector );
 free( MVector );

 return 1;

} /* End of StandardVEFlacAnalysis */


/*
%F
*/
static int StandardVEFlacPrintResult( int iteration, double *U, double *V )
{
 int i;

/* Check to see if this step must be processed
 */
 if( !Config.print_step || ((iteration != 1) && (iteration%Config.print_step)) )
  return 0;

/* Update number of result steps
 */
 Config.num_step++;

/* Process output
 */
 IoStartSave( );

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

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

 return 1;
} /* End of StandardVEFlacPrintResult */


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

/*
%F This function initializes the sub-class STANDARD.
*/
void StandardVEFlacInit( void );
void StandardVEFlacInit( void )
{
/* Initialize STANDARD_VE_FLAC driver sub-class
 */
 DrvClass[STANDARD_VE_FLAC].new      = StandardVEFlacNew;
 DrvClass[STANDARD_VE_FLAC].free     = StandardVEFlacFree;
 DrvClass[STANDARD_VE_FLAC].analysis = StandardVEFlacAnalysis;
 DrvClass[STANDARD_VE_FLAC].printres = StandardVEFlacPrintResult;

} /* End of StandardVEFlacInit */


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

---