standard.c

Go to the documentation of this file.

/*
%M This modules contains the driver methods to solve a problem using the 
   dynamic relax algorithm.
%a Joao Luiz Elias Campos.
%d July 27th, 1999.
%r $Id: standard.c,v 1.1 2004/06/22 05:29:59 joaoluiz Exp $
%w (C) COPYRIGHT 1995-1996, Eduardo Nobre Lages.
   (C) COPYRIGHT 1997-1999, 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
*    Modificadas as funcões StandardPrintResult, StandardAnalysis,
*    que passam a retornar un valor int.      
*
*  Modified: 23-Fev-2006    Juan Pablo Ibanez
*    Modificada a funcao StandardPrintResult, 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"
#include "rui.h"


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

/*
** ------------------------------------------------------------------------
** Local functions:
*/
static void StandardNew(sDriver **);
static void StandardFree(sDriver *);
static int  StandardAnalysis(UI_State *);
static int  StandardPrintResult(int, double *, double *);


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

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

} /* End of StandardNew */


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

} /* End of StandardFree */


/*
%F This function process the probleam analysis using a dynamic relax 
   algorithm.
*/
static int StandardAnalysis(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 StandardAnalysis */


/*
%F
*/
static int StandardPrintResult( 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 1;

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

/* Process output
 */
 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 );

 return 1;

} /* End of StandardPrintResult */


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

/*
%F This function initializes the sub-class STANDARD.
*/
void StandardInit( void );
void StandardInit( void )
{
/* Initialize STANDARD driver sub-class
 */
 DrvClass[STANDARD].new      = StandardNew;
 DrvClass[STANDARD].free     = StandardFree;
 DrvClass[STANDARD].analysis = StandardAnalysis;
 DrvClass[STANDARD].printres = StandardPrintResult;

} /* End of StandardInit */


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

---